@huynle/hub 0.8.0 → 0.8.1

package/packages/cli/src/teams-mcp.ts

@@ -57,6 +57,63 @@ const SPEC_FIELDS = {
   metadata: { type: "object", additionalProperties: STRING, description: "String key/value pairs (keys are slugs)." },
   projects: { ...STRINGS, description: "Project names the team works on." },
 } as const
+// (FX-03, l3vynemo) The launch spec as validateLaunchSpec (src/central/agent/launch-spec.ts) takes it: NESTED sections,
+// unlike the plain launch tool's flat fields. Keep the two in step. No additionalProperties: false, so a flat field
+// reaches the hub, whose answer names the nested place it belongs (a client-side schema refusal would not).
+const LAUNCH = {
+  type: "object",
+  description:
+    "A launch spec (nested, as POST /api/agent/launches takes; unlike the launch tool's flat fields): workspace{repo, mode, branch, base, remote} is required; placement{machine, labels, mode}, runtime{kind, profile}, end{when, timeout, cleanup} and the top-level fields are optional; key is set by staffing (send idempotencyKey instead). The role's prefs fill harness, model and placement.machine, and its profile fills agentProfile, when not given. A flat field (repo, machine, cleanup at the top) is refused with the nested place it belongs.",
+  properties: {
+    workspace: {
+      type: "object",
+      description: "Where the member works on its machine.",
+      properties: {
+        repo: { ...STRING, description: "The repository's absolute path on the machine." },
+        mode: { type: "string", enum: ["worktree", "checkout", "clone"], description: "worktree (default; needs branch), checkout, or clone (needs remote)." },
+        branch: { ...STRING, description: "The branch to create or check out (a safe git branch name; required for worktree)." },
+        base: { ...STRING, description: "What a new branch starts from." },
+        remote: { ...STRING, description: "An https or ssh git remote, without credentials (required for clone)." },
+      },
+      required: ["repo"],
+    },
+    placement: {
+      type: "object",
+      description: "Which machine runs it.",
+      properties: {
+        machine: { ...STRING, description: "A machine ID or name." },
+        labels: { type: "object", additionalProperties: STRING, description: "Node labels to match." },
+        mode: { type: "string", enum: ["require", "prefer"], description: "require (default) or prefer the machine/labels." },
+      },
+    },
+    runtime: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ["host", "openshell"], description: "host (default) or openshell (clone workspaces only)." },
+        profile: { ...STRING, description: "An openshell sandbox profile (openshell only)." },
+      },
+    },
+    end: {
+      type: "object",
+      description: "When the launch ends.",
+      properties: {
+        when: { type: "string", enum: ["idle", "asked", "never"], description: "idle (default), asked or never." },
+        timeout: { type: ["string", "number"], description: "1 minute to 30 days: seconds, or 30m, 4h, 2d." },
+        cleanup: { type: "string", enum: ["keep", "remove"], description: "keep (default) or remove the workspace at the end." },
+      },
+    },
+    name: { ...STRING, description: "The session's @name, without the @." },
+    roles: { ...STRINGS, description: "Roles the session claims (up to 10)." },
+    harness: { ...STRING, description: "The harness (default opencode)." },
+    agent: { ...STRING, description: "The harness agent." },
+    model: { ...STRING, description: "provider/model." },
+    prompt: { ...STRING, description: "The first prompt (up to 10000 characters)." },
+    intent: { ...STRING, description: "What the session is for (one line)." },
+    labels: { type: "object", additionalProperties: STRING, description: "Free-form app labels." },
+    agentProfile: { type: "object", properties: { profileID: STRING, version: { type: "integer", minimum: 1 } }, required: ["profileID", "version"], description: "The profile version to pin (needs profiles:assign for an app)." },
+  },
+  required: ["workspace"],
+} as const
 const SCOPES = "App tokens need scope teams:read (reads) or teams:manage (changes); seats, status and staffing also need sessions:read. Session tokens read only teams they are seated in and never change definitions. Team roles confer no authority."
 
 class ArgError extends Error {}
@@ -352,7 +409,7 @@ export const teamTools: readonly TeamTool[] = [
   {
     name: "team_staff",
     description: `Staff a role: attach an existing session (sessionID, any machine) or launch a new member (launch: a launch spec as the launch tool takes). An agent needs the user's grants (roles for the session's project; launch for a repo) or the hub answers needs_user; staffing never issues grants. ${SCOPES}`,
-    properties: { team: TEAM, role: STRING, sessionID: { ...STRING, description: "An existing session (ses_…)." }, launch: { type: "object", description: "A launch spec (repo, harness, model, prompt, …)." }, idempotencyKey: IDEMPOTENCY },
+    properties: { team: TEAM, role: STRING, sessionID: { ...STRING, description: "An existing session (ses_…)." }, launch: LAUNCH, idempotencyKey: IDEMPOTENCY },
     required: ["team", "role"],
     readOnly: false,
     run: async (hub, args, signal) => {
@@ -386,7 +443,7 @@ export const teamTools: readonly TeamTool[] = [
   {
     name: "team_replace",
     description: `Replace a seat by an existing session (sessionID) or a new launch (launch): the old seat ends at once and the new member gets the slot's next generation. Send the seat's revision (team_status). ${SCOPES}`,
-    properties: { team: TEAM, staffingID: STRING, sessionID: STRING, launch: { type: "object" }, expectedRevision: { ...REVISION, description: "The seat's revision you read (team_status)." } },
+    properties: { team: TEAM, staffingID: STRING, sessionID: STRING, launch: LAUNCH, expectedRevision: { ...REVISION, description: "The seat's revision you read (team_status)." } },
     required: ["team", "staffingID", "expectedRevision"],
     readOnly: false,
     run: async (hub, args, signal) => {

package/packages/codex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-codex",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "The Codex app-server spoke: attaches to Codex's app-server (its own over stdio, and the shared daemon's socket when present), and the `hub codex` wrapper (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/codex/src/paths.ts

@@ -1,12 +1,12 @@
 // Where the Codex spoke looks and keeps its files. It only reads Codex's home (CODEX_HOME, default ~/.codex) to find
 // the shared daemon's socket; its own files live in <hub state dir>/codex (the hub state dir is $HUB_STATE_DIR, else
-// ~/.local/state/hub), a private (0700) directory holding the service's pid file (spoke.pid) and its log.
+// $XDG_STATE_HOME/hub or ~/.local/state/hub), a private (0700) directory holding the service's pid file (spoke.pid) and its log.
 // $HUB_CODEX_DAEMON_SOCKET names another daemon socket, or "off" for none.
 import { chmodSync, lstatSync, mkdirSync, readFileSync } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
 import { hubEnv, type Env } from "../../../src/env.ts"
-import { APP_DIR, stateBase } from "../../../src/migrate.ts"
+import { resolveHubStateDir } from "../../../src/migrate.ts"
 
 export function codexHome(env: Env = process.env, home: string = homedir()): string {
   return env.CODEX_HOME || path.join(home, ".codex")
@@ -20,7 +20,7 @@ export function daemonSocketPath(env: Env = process.env, home: string = homedir(
 }
 
 export function codexStateDir(env: Env = process.env, home: string = homedir()): string {
-  return path.join(hubEnv(env).HUB_STATE_DIR || path.join(stateBase(home), APP_DIR), "codex")
+  return path.join(resolveHubStateDir(env, home).dir, "codex")
 }
 
 export const pidFile = (env: Env = process.env, home: string = homedir()) => path.join(codexStateDir(env, home), "spoke.pid")

package/packages/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-node",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "`hub node`: the per-machine daemon that prepares, collects and cleans up launch workspaces (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/node/src/config.ts

@@ -13,7 +13,7 @@
 // `opencode` (RF-04, opencode-warm.ts): foreground `opencode serve` processes to keep warm besides the background
 // service (loopback URLs only, the password from a private file), and the project directories to keep loaded on the
 // service (`directories`) or on a server (its own `directories`); absent: the projects of recent sessions under
-// workspaceRoots.
+// workspaceRoots. `opencode.timeoutSeconds` (1–300, default 30) bounds each warm request.
 import { readFileSync } from "node:fs"
 import { homedir, hostname } from "node:os"
 import path from "node:path"
@@ -55,6 +55,8 @@ export interface OpenCodeNodeConfig {
   /** Project directories the background service keeps loaded; absent: recent sessions' projects under workspaceRoots. */
   readonly directories?: readonly string[]
   readonly servers: readonly OpenCodeServerConfig[]
+  /** The warmer's per-request timeout in seconds (1–300; default opencode-warm.ts WARM_TIMEOUT_MS). */
+  readonly timeoutSeconds?: number
 }
 
 /** A foreground `opencode serve` the node keeps warm. */
@@ -205,7 +207,13 @@ function normalizeOpenCode(raw: unknown, problems: string[]): OpenCodeNodeConfig
     problems.push(`opencode.servers: at most ${OPENCODE_SERVERS_MAX} servers; the rest are ignored`)
     servers.length = OPENCODE_SERVERS_MAX
   }
-  return { ...(directories ? { directories } : {}), servers }
+  let timeoutSeconds: number | undefined
+  if (raw.timeoutSeconds !== undefined) {
+    const t = raw.timeoutSeconds
+    if (typeof t === "number" && Number.isInteger(t) && t >= 1 && t <= 300) timeoutSeconds = t
+    else problems.push("opencode.timeoutSeconds must be a whole number of seconds from 1 to 300")
+  }
+  return { ...(directories ? { directories } : {}), servers, ...(timeoutSeconds !== undefined ? { timeoutSeconds } : {}) }
 }
 
 function normalizeHarnesses(raw: unknown, problems: string[]): Record<string, boolean> | undefined {

package/packages/node/src/opencode-warm.ts

@@ -16,12 +16,12 @@
 // origin only. Logs on changes only.
 import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, realpathSync, statSync, type Stats } from "node:fs"
 import path from "node:path"
-import { readFile } from "node:fs/promises"
 import { listServiceSessions, type ListingClient, type RawProject, type RawSession } from "../../../src/spoke/listing.ts"
 
 /** How often the daemon asks (a restarted server is warmed within this). */
 export const WARM_INTERVAL_MS = 30_000
-const WARM_TIMEOUT_MS = 10_000
+/** Per-request timeout (node.json opencode.timeoutSeconds overrides it): long enough for a busy machine's first project load. */
+export const WARM_TIMEOUT_MS = 30_000
 /** Project locations warmed per server and tick, besides its default location. */
 export const WARM_DIRECTORIES_MAX = 8
 /** Automatic project locations: sessions updated within this many days, from one page of this many. */
@@ -30,6 +30,8 @@ const SESSION_PAGE = 100
 /** Loopback hosts asked as they are (after URL normalization); localhost is rewritten to 127.0.0.1. */
 const LOOPBACK = new Set(["127.0.0.1", "[::1]"])
 const PASSWORD_FILE_MAX = 4096
+/** Largest service.json read (OpenCode's is a few hundred bytes). */
+const REGISTRATION_MAX = 64 * 1024
 
 /** A local OpenCode server (the service's registration, or a node.json server with its password). */
 export interface WarmEndpoint {
@@ -243,23 +245,40 @@ export class OpenCodeWarmer {
 
 /**
  * OpenCode's background service from its registration file (service.json: {url, pid, password?, id?, version?}),
- * without any request: undefined when the file is missing or malformed or its process is gone. The URL is passed on
- * as it is; OpenCodeWarmer.tick decides whether it may be asked.
+ * without any request: undefined when the file is missing or malformed, is not this user's own (a symbolic link, not
+ * owned by this uid, or writable by group or others), or its process is gone or another user's (EPERM). The URL is
+ * passed on as it is; OpenCodeWarmer.tick decides whether it may be asked.
  */
-export async function readServiceRegistration(file: string): Promise<WarmEndpoint | undefined> {
+export async function readServiceRegistration(file: string, options: { readonly uid?: number } = {}): Promise<WarmEndpoint | undefined> {
+  const uid = options.uid ?? (typeof process.getuid === "function" ? process.getuid() : undefined)
   let info: unknown
+  let fd: number | undefined
   try {
-    info = JSON.parse(await readFile(file, "utf8"))
+    const before = lstatSync(file)
+    if (!before.isFile()) return undefined
+    fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0))
+    const stat = fstatSync(fd)
+    if (!stat.isFile() || stat.dev !== before.dev || stat.ino !== before.ino) return undefined
+    if ((stat.mode & 0o022) !== 0) return undefined
+    if (uid !== undefined && stat.uid !== uid) return undefined
+    if (stat.size > REGISTRATION_MAX) return undefined
+    // Read through the descriptor that was checked (no second open by path).
+    const buffer = Buffer.alloc(REGISTRATION_MAX + 1)
+    const length = readSync(fd, buffer, 0, buffer.length, 0)
+    if (length > REGISTRATION_MAX) return undefined
+    info = JSON.parse(buffer.subarray(0, length).toString("utf8"))
   } catch {
     return undefined
+  } finally {
+    if (fd !== undefined) closeSync(fd)
   }
   if (!info || typeof info !== "object") return undefined
   const { url, pid, password } = info as Record<string, unknown>
   if (typeof url !== "string" || url.length > 2048 || typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) return undefined
   try {
     process.kill(pid, 0)
-  } catch (cause) {
-    if ((cause as NodeJS.ErrnoException).code !== "EPERM") return undefined
+  } catch {
+    return undefined // gone (ESRCH), or another user's process (EPERM): not this user's service
   }
   return typeof password === "string" ? { url, auth: { type: "basic", username: "opencode", password } } : { url }
 }

package/packages/node/src/run.ts

@@ -50,9 +50,10 @@ export const openCodeServiceFile = (env: Env, home: string): string =>
 function startOpenCodeWarmers(config: NodeConfig, service: () => Promise<WarmEndpoint | undefined>, log: (line: string) => void, signal: AbortSignal): void {
   const roots = () => config.workspaceRoots
   const directories = config.opencode?.directories
-  new OpenCodeWarmer({ discover: service, log, roots, ...(directories ? { directories } : {}) }).start(signal)
+  const timeout = config.opencode?.timeoutSeconds !== undefined ? { timeoutMs: config.opencode.timeoutSeconds * 1000 } : {}
+  new OpenCodeWarmer({ discover: service, log, roots, ...timeout, ...(directories ? { directories } : {}) }).start(signal)
   for (const server of config.opencode?.servers ?? []) {
-    new OpenCodeWarmer({ discover: serverEndpoint(server), log, name: "the OpenCode server", roots, ...(server.directories ? { directories: server.directories } : {}) }).start(signal)
+    new OpenCodeWarmer({ discover: serverEndpoint(server), log, name: "the OpenCode server", roots, ...timeout, ...(server.directories ? { directories: server.directories } : {}) }).start(signal)
   }
 }
 

package/packages/preset/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-preset",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "The preset spoke: drives a harness without a spoke of its own through a terminal pane (tmux), described by a data-only preset; official presets in presets/ (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-protocol",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "Hub ↔ spoke wire protocol (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/protocol/src/index.ts

@@ -161,6 +161,11 @@ export interface SessionInfo {
    */
   readonly agent?: string
   readonly contextRevision?: number
+  /**
+   * (FX-07) The session is locked as a Concierge session on this spoke (sent from the first sessions frame after a
+   * restart, before `agent` or `contextRevision` are known). The hub treats it as a Concierge session.
+   */
+  readonly locked?: true
 }
 
 /** Most files a revert summary or preview lists (`filesTotal` counts them all). */
@@ -911,7 +916,8 @@ function isSession(v: unknown): v is SessionInfo {
     (v.terminal === undefined || isTerminal(v.terminal)) &&
     (v.revert === undefined || isSessionRevert(v.revert)) &&
     (v.agent === undefined || (nonEmpty(v.agent) && v.agent.length <= AGENT_NAME_MAX)) &&
-    (v.contextRevision === undefined || (Number.isSafeInteger(v.contextRevision) && (v.contextRevision as number) >= 0))
+    (v.contextRevision === undefined || (Number.isSafeInteger(v.contextRevision) && (v.contextRevision as number) >= 0)) &&
+    (v.locked === undefined || v.locked === true)
   )
 }
 

package/packages/protocol/src/launch.ts

@@ -103,6 +103,14 @@ export interface LaunchArtifacts {
   readonly dirty?: boolean
 }
 
+/** Why a queued launch waits (FX-02): capacity (a fitting node is full), no_match (no node fits), active (the per-user cap). */
+export interface LaunchWaitingInfo {
+  readonly wait: "capacity" | "no_match" | "active"
+  readonly reason: string
+  /** ms epoch: since when it has waited for this kind of reason. */
+  readonly since: number
+}
+
 /** A launch as the API reports it. */
 export interface LaunchInfo {
   readonly id: string
@@ -118,6 +126,12 @@ export interface LaunchInfo {
   readonly name?: string
   readonly outcome?: LaunchOutcome
   readonly artifacts?: LaunchArtifacts
+  /** Only while queued: why it waits (`reason` is the same text). */
+  readonly waiting?: LaunchWaitingInfo
+  /** The launcher's label when it launched (an app token's label). */
+  readonly byLabel?: string
+  /** The app token that launched it was revoked: it still runs and counts toward the cap until stopped. */
+  readonly launcherRevoked?: boolean
 }
 
 // ---------- checks ----------

package/packages/runtime-openshell/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-runtime-openshell",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "The `openshell` runtime of `hub node`: launches in NVIDIA OpenShell sandboxes, driven through the openshell CLI (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/runtime-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-runtime-sdk",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "The Runtime interface `hub node` runtimes implement (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-sdk",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "Typed client for the hub's /api/agent (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/packages/sdk/src/errors.ts

@@ -21,6 +21,7 @@ export type ErrorCode =
   | "rate_limited"
   | "internal"
   | "offline"
+  | "busy"
   | (string & {})
 
 export interface Envelope {

package/packages/sdk/src/index.ts

@@ -11,5 +11,6 @@ export * from "./concierge.ts"
 export * from "./envelope.ts"
 export * from "./errors.ts"
 export * from "./sse.ts"
+export * from "./wake.ts"
 export * from "./webhook.ts"
 export type * from "./types.ts"

package/packages/sdk/src/types.ts

@@ -269,8 +269,11 @@ export type MessageKind = "msg" | "ask" | "reply" | "decline"
 /** `sent` for msg/reply/decline; asks are open until answered, declined or expired. */
 export type MessageState = "sent" | "open" | "answered" | "declined" | "expired"
 /** How a message reached its recipient session. */
-/** (CON-10) "dropped": it was pending for a session that ended for good (a retired Concierge session); never delivered. */
-export type MessageDelivery = "steer" | "turn" | "queued" | "retained" | "pending" | "dropped"
+/**
+ * (CON-10) "dropped": it was pending for a session that ended for good (a retired Concierge session); never delivered.
+ * "expired": it was pending for 24 h (its recipient stayed offline or busy); never delivered, and its sender was told.
+ */
+export type MessageDelivery = "steer" | "turn" | "queued" | "retained" | "pending" | "dropped" | "expired"
 
 /** A stored agent message. */
 export interface AgentMessage {
@@ -296,10 +299,21 @@ export interface AgentMessage {
   readonly answer?: { readonly id: string; readonly at: number }
 }
 
+/**
+ * Why a message to a session did not start a turn: the sender asked wake:false, the recipient is a subagent
+ * (never woken), the reply chain went past the hop cap (8 hops without a human turn), or the recipient's wake
+ * budget (30 per 10 minutes) is spent. The message is still delivered.
+ */
+export type WakeSkip = "wake_false" | "subagent" | "hop_cap" | "budget"
+
 /** POST /api/agent/msg and /ask: the stored message and how it was delivered (none: stored only). */
 export interface Sent {
   readonly message: AgentMessage
   readonly delivery?: MessageDelivery
+  /** Messages to a session: whether the hub sent it to wake the recipient (absent from hubs before 0.8.1). */
+  readonly woke?: boolean
+  /** When woke is false: why. */
+  readonly wakeSkipped?: WakeSkip
 }
 
 /** POST /api/agent/msg or /ask with all: one per session. */
@@ -577,6 +591,12 @@ export interface LaunchView {
   readonly updated: number
   /** Who launched it: `user`, `app:<token id>` or a session ID. */
   readonly by?: string
+  /** The launcher's label when it launched (an app token's label). */
+  readonly byLabel?: string
+  /** The app token that launched it was revoked: it still runs and counts toward the cap until stopped. */
+  readonly launcherRevoked?: boolean
+  /** Only while queued: why it waits (`reason` is the same text). */
+  readonly waiting?: { readonly wait: "capacity" | "no_match" | "active"; readonly reason: string; readonly since: number }
   readonly machineID?: string
   readonly directory?: string
   readonly sessionID?: string

package/packages/sdk/src/wake.ts

@@ -0,0 +1,20 @@
+// Why a message did not wake its recipient (Sent.woke / Sent.wakeSkipped, hub 0.8.1), in the words the CLI, `hub mcp`
+// and the OpenCode hub tool show: one place so every client says the same thing.
+import type { Sent, WakeSkip } from "./types.ts"
+
+/** One short reason per WakeSkip. */
+export const WAKE_SKIP_TEXT: Readonly<Record<WakeSkip, string>> = {
+  wake_false: "sent without a wake",
+  subagent: "subagents are never woken",
+  hop_cap: "hop limit reached (8 agent messages without a human turn)",
+  budget: "wake budget spent (30 per 10 minutes)",
+}
+
+/**
+ * ` — wake skipped: <reason>` when the hub did not wake the recipient and the message waits for a later turn; empty
+ * when it woke, went into a running turn (steer) or started one, or the hub did not say (hubs before 0.8.1).
+ */
+export function wakeSkipNote({ delivery, woke, wakeSkipped }: Pick<Sent, "delivery" | "woke" | "wakeSkipped">): string {
+  if (woke !== false || !wakeSkipped || delivery === "steer" || delivery === "turn") return ""
+  return ` — wake skipped: ${WAKE_SKIP_TEXT[wakeSkipped] ?? wakeSkipped}`
+}

package/packages/spoke-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huynle/hub-spoke-sdk",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "description": "Harness-neutral spoke building blocks: hub connection, enrollment, tokens, idempotent deliver, prompt references, HarnessSpoke (internal; shipped inside @huynle/hub, not published on its own).",
   "license": "MIT",

package/src/central/agent/acting.ts

@@ -790,6 +790,9 @@ export function auditOf(cause: unknown): [AuditDecision, AuditOutcome] {
       return ["forbidden", "refused"]
     case "rate_limited":
       return ["rate_limited", "refused"]
+    // (FX-07) The hub's state did not answer in time: refused, and Activity says the hub was busy.
+    case "busy":
+      return ["busy", "refused"]
     case "needs_user":
       return ["needs_user", "refused"]
     case "gone":

package/src/central/agent/audit.ts

@@ -29,7 +29,7 @@ export const AUDIT_PAGE_DEFAULT = 100
 export const AUDIT_PAGE_MAX = 500
 
 /** The policy's decision: allowed, or why not. */
-export type AuditDecision = "allow" | "needs_user" | "forbidden" | "paused" | "rate_limited"
+export type AuditDecision = "allow" | "needs_user" | "forbidden" | "paused" | "rate_limited" | "busy"
 /** What happened: done, failed, raced (gone), the spoke could not (offline, unsupported), escalated or refused. */
 export type AuditOutcome = "ok" | "failed" | "gone" | "offline" | "unsupported" | "escalated" | "refused"
 

package/src/central/agent/decisions.ts

@@ -106,6 +106,8 @@ export interface ActAction {
   readonly target: string
   /** The verb's validated input (requestID, formID, answer, text). */
   readonly input: Readonly<Record<string, unknown>>
+  /** (FX-05) deny: the permission it would deny, for the console's card. */
+  readonly request?: DecisionRequest
 }
 
 /** An escalated permission request: the answer replies to it as the user. */
@@ -118,6 +120,56 @@ export interface PermissionAction {
   readonly sessionID: string
   /** The agent asked to approve it always. */
   readonly always: boolean
+  /** (FX-05) What it asks, for the console's card (absent when the hub did not know the request's details). */
+  readonly request?: DecisionRequest
+  /** (FX-05) Why the hub sent it to the user (the evaluation's reason). */
+  readonly reason?: string
+}
+
+/**
+ * (FX-05) A permission request as a Decision shows it (bounded): its kind, what it applies to and the patterns an
+ * "always" would save. What was not stored is recorded, so a shortened command never reads as complete: the totals
+ * when items were dropped, each cut item with its full length, and `truncated` when the hub received the request
+ * already shortened (src/status.ts permissionRequest). The console renders it as text; the Concierge's Decision reads
+ * leave it out (concierge/board-routes.ts conciergeDecisionView).
+ */
+export interface DecisionRequest {
+  readonly action: string
+  readonly resources: readonly string[]
+  readonly save?: readonly string[]
+  /** How many resources the request had, when more than were stored. */
+  readonly resourcesTotal?: number
+  /** How many save patterns it had, when more than were stored. */
+  readonly savesTotal?: number
+  /** Stored items cut at DECISION_REQUEST_TEXT characters, with their full length. */
+  readonly cut?: readonly { readonly field: "resources" | "save"; readonly index: number; readonly length: number }[]
+  /** The hub received the request already shortened. */
+  readonly truncated?: true
+}
+
+/** Resources (and save patterns) a Decision keeps of a request, and the characters of each. */
+export const DECISION_REQUEST_ITEMS = 20
+export const DECISION_REQUEST_TEXT = 2_000
+
+/** A permission request, bounded for a Decision, with what was not stored. */
+export function decisionRequest(request: { readonly action: string; readonly resources: readonly string[]; readonly save?: readonly string[]; readonly truncated?: true }): DecisionRequest {
+  const cut: { field: "resources" | "save"; index: number; length: number }[] = []
+  const bound = (field: "resources" | "save", list: readonly string[]) =>
+    list.slice(0, DECISION_REQUEST_ITEMS).map((r, index) => {
+      if (r.length > DECISION_REQUEST_TEXT) cut.push({ field, index, length: r.length })
+      return r.slice(0, DECISION_REQUEST_TEXT)
+    })
+  const resources = bound("resources", request.resources)
+  const save = request.save?.length ? bound("save", request.save) : undefined
+  return {
+    action: request.action.slice(0, DECISION_REQUEST_TEXT),
+    resources,
+    ...(save ? { save } : {}),
+    ...(request.resources.length > resources.length ? { resourcesTotal: request.resources.length } : {}),
+    ...(save && request.save!.length > save.length ? { savesTotal: request.save!.length } : {}),
+    ...(cut.length ? { cut } : {}),
+    ...(request.truncated ? { truncated: true as const } : {}),
+  }
 }
 
 /** A grant an agent requested (grant-requests.ts): approving creates it as the user. */
@@ -457,11 +509,15 @@ export class Decisions {
 
   // ---- internals ----------------------------------------------------------------------------------------
 
-  /** Whether the session is one of the user's Concierge sessions; a failed read is no label (never fails the ask). */
+  /**
+   * Whether the session is one of the user's Concierge sessions; a failed read is no label (never fails the ask).
+   * (FX-07) A read that timed out (`busy`) refuses the ask instead: the label could not be checked (fail closed).
+   */
   private async isConcierge(userID: string, sessionID: string): Promise<boolean> {
     try {
       return (await this.deps.concierge?.(userID, sessionID)) === true
-    } catch {
+    } catch (cause) {
+      if (cause instanceof AgentError && cause.code === "busy") throw cause
       return false
     }
   }