@huynle/hub 0.7.3 → 0.8.0

package/src/central/agent/launch-engine.ts

@@ -6,7 +6,8 @@
 // - Placement (placement.ts, under the user's fenced lease) moves it to provisioning on a node; the engine then
 //   runs one pipeline per launch: prepare on the node (requestNode) → launch create on the machine's service spoke
 //   (feature "launch": directory, launchID, agent, model) → roles (byUser only for the user's own launches; a refused
-//   role is noted, not fatal) → the name (taken meanwhile: failed) → the primer (Delivery.prime, so roles and name
+//   role is noted, not fatal) → the name (taken meanwhile: failed) → the spec's intent (CON-02, source launch; a
+//   failure is noted, not fatal) → the primer (Delivery.prime, so roles and name
 //   are in it) → the prompt (actions.prompt, resetHops false; marked prompted first, so at most once) → running.
 //   A stop between steps ends it stopped; the node going away ends it lost; anything else ends it failed.
 // - openshell launches (design §6.4, decision lk6gn3u7): after prepare the engine mints the launch's hlt1 token
@@ -119,6 +120,10 @@ export interface LaunchEngineDeps {
   readonly onLaunchChanged?: (launch: Launch) => void
   /** Cluster mode: the leader's supervisor, for an engine that does not supervise (see EngineSupervisor). */
   readonly supervisor?: EngineSupervisor
+  /** (HWA-15) Applies a launch's agentProfile before its prompt; returns notes for the reason, never throws. */
+  readonly profiles?: { applyAtLaunch(userID: string, sessionID: string, ref: { readonly profileID: string; readonly version: number }): Promise<string[]> }
+  /** (CON-02) Stores the spec's intent as the session's intent (source launch) at identify. */
+  readonly intents?: { storeLaunch(userID: string, sessionID: string, text: string, by?: string): Promise<void> }
 }
 
 /** Node events of every pod (cluster mode; the same as local ones on a single hub). */
@@ -771,11 +776,20 @@ export class LaunchEngine {
       }
     }
     if (spec.name !== undefined) await directory.setName(userID, sessionID, spec.name)
+    if (spec.intent !== undefined && this.deps.intents) {
+      try {
+        await this.deps.intents.storeLaunch(userID, sessionID, spec.intent, launch.by ?? "user")
+      } catch (cause) {
+        notes.push(`intent not stored: ${errorText(cause)}`)
+      }
+    }
     await delivery.prime(userID, sessionID)
+    if (spec.agentProfile) notes.push(...(this.deps.profiles ? await this.deps.profiles.applyAtLaunch(userID, sessionID, spec.agentProfile) : ["agentProfile not applied: this hub does not apply profiles"]))
     checkpoint()
     if (spec.prompt !== undefined) {
       await this.updateWork(userID, launch.id, { prompted: true })
-      const prompted = await actions.prompt({ sessionID, text: spec.prompt, resetHops: false })
+      // (CON-10) The launch's prompt is the session's first prompt (its intent), even when the launch named it.
+      const prompted = await actions.prompt({ sessionID, text: spec.prompt, resetHops: false, intent: "first" })
       if (prompted.outcome === "offline") throw new Error("The session went offline before its prompt")
       if (prompted.outcome === "unsupported") throw new Error(unsupportedMessage(prompted))
       if (prompted.mode === "steer") this.sawWorking(userID, launch.id)

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

@@ -13,6 +13,7 @@
 // → kill switch again → the engine. Apps and sessions see and stop only the launches they started (by); any other
 // launch, like another user's, is 404 not_found. The engine applies the per-user launch caps (rate_limited).
 // Every outcome once the body is valid is in the agent audit (verb launch, or launch.stop for DELETE).
+import { boundedJson } from "./body"
 import type { LaunchInfo, LaunchSpec as WireSpec } from "../../protocol"
 import { Feed } from "../cluster/feed"
 import type { ActingSwitch } from "./acting-switch"
@@ -120,7 +121,7 @@ const invalid = (message: string) => new AgentError("invalid", message)
 const notFound = (id: string) => new AgentError("not_found", `No launch ${id}`)
 
 async function bodyOf(request: Request): Promise<unknown> {
-  return JSON.parse(await request.text())
+  return boundedJson(request)
 }
 
 /** ?state=a,b and ?label=k=v (repeated). */
@@ -197,6 +198,10 @@ export function launchRoutes(deps: LaunchRoutesDeps): AgentRoute[] {
       async handle({ request, actor, user }) {
         const raw = await bodyOf(request)
         const spec = validateLaunchSpec(raw)
+        // HWA-15: naming a profile pins it; apps need profiles:assign, sessions never pin profiles.
+        if (spec.agentProfile && actor.kind !== "user" && !(actor.kind === "app" && actor.scopes.includes("profiles:assign"))) {
+          throw new AgentError("forbidden", "A launch's agentProfile needs scope profiles:assign; sessions cannot pin profiles")
+        }
         const by = launchedBy(actor)
         const held = spec.key === undefined ? undefined : (await launches.list(user.id)).find((l) => l.spec.key === spec.key)
         let launchID: string | undefined

package/src/central/agent/launch-spec.ts

@@ -10,7 +10,9 @@
 //   cleanup keep, no timeout.
 // LaunchSpec is defined here until packages/protocol carries it (P4-T1); keep the two in step.
 
+import { type LaunchAgentProfile, launchAgentProfileProblem } from "../../protocol"
 import { AgentError } from "./errors"
+import { intentText } from "./intents"
 import { isReservedName, parseAddress, validName } from "./names"
 import { canonicalProject, parseDuration } from "./policy"
 
@@ -66,9 +68,13 @@ export interface LaunchSpec {
   readonly runtime: LaunchRuntime
   readonly placement: LaunchPlacement
   readonly prompt?: string
+  /** (CON-02) Stored as the session's intent (source launch) when it is identified. */
+  readonly intent?: string
   /** Free-form app labels (never interpreted by the hub). */
   readonly labels: Readonly<Record<string, string>>
   readonly end: LaunchEnd
+  /** (HWA-15) The profile version pinned and applied before the prompt (explicit version; never latest). */
+  readonly agentProfile?: LaunchAgentProfile
 }
 
 export const KEY_MAX = 200
@@ -83,7 +89,7 @@ export const MODEL_MAX = 200
 export const LAUNCH_TIMEOUT_MIN_MS = 60_000
 export const LAUNCH_TIMEOUT_MAX_MS = 30 * 86_400_000
 
-const FIELDS = ["key", "name", "roles", "harness", "agent", "model", "workspace", "runtime", "placement", "prompt", "labels", "end"]
+const FIELDS = ["key", "name", "roles", "harness", "agent", "model", "workspace", "runtime", "placement", "prompt", "intent", "labels", "end", "agentProfile"]
 const WORKSPACE_FIELDS = ["repo", "mode", "branch", "base", "remote"]
 const RUNTIME_FIELDS = ["kind", "profile"]
 const PLACEMENT_FIELDS = ["labels", "machine", "mode"]
@@ -254,8 +260,13 @@ export function validateLaunchSpec(input: unknown): LaunchSpec {
     if (typeof input.prompt !== "string" || input.prompt.length > PROMPT_MAX || PROMPT_CONTROL.test(input.prompt)) throw invalid(`prompt is text of up to ${PROMPT_MAX} characters`)
     prompt = input.prompt
   }
+  // (CON-02) What the session is for: untrusted, sanitised to one line, at most INTENT_MAX characters.
+  const intent = input.intent === undefined ? undefined : intentText(input.intent)
   const labels = validLabels(input.labels, "labels")
   const end = validEnd(input.end)
+  const profileProblem = input.agentProfile === undefined ? undefined : launchAgentProfileProblem(input.agentProfile)
+  if (profileProblem) throw invalid(profileProblem)
+  const agentProfile = input.agentProfile === undefined ? undefined : { profileID: (input.agentProfile as LaunchAgentProfile).profileID, version: (input.agentProfile as LaunchAgentProfile).version }
   return {
     ...(key !== undefined ? { key } : {}),
     ...(name !== undefined ? { name } : {}),
@@ -267,8 +278,10 @@ export function validateLaunchSpec(input: unknown): LaunchSpec {
     runtime,
     placement,
     ...(prompt !== undefined ? { prompt } : {}),
+    ...(intent !== undefined ? { intent } : {}),
     labels,
     end,
+    ...(agentProfile ? { agentProfile } : {}),
   }
 }
 

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

@@ -25,6 +25,7 @@
 //   user, who owns every party); others get not_found.
 // - Messaging off (UserRecord.agent.messagingPaused): msg, ask, reply and decline answer paused; reading works.
 // - Every stored message is published on the MessageFeed (GET /api/agent/watch 'message' events, waiters).
+import { boundedJson } from "./body"
 import { Feed } from "../cluster/feed"
 import type { Store } from "../store"
 import type { AgentActor } from "./actor"
@@ -70,7 +71,7 @@ const READ = { session: true, scope: "messages:read" } as const
 type Body = Record<string, unknown>
 
 async function bodyOf(request: Request): Promise<Body> {
-  const body = await request.json()
+  const body = await boundedJson(request)
   if (typeof body !== "object" || body === null || Array.isArray(body)) throw new AgentError("invalid", "Body must be a JSON object")
   return body as Body
 }

package/src/central/agent/messages.ts

@@ -7,6 +7,7 @@
 // - Caps: each party (session, the user, an app) keeps its latest SESSION_MESSAGES; a message no party keeps
 //   is deleted. Per user, at most USER_MESSAGES messages / USER_BYTES; over either, the oldest go (down to
 //   90%). Eviction keeps open asks while anything else can go.
+//   Deleting a message records the newest evicted `at` (retention(): the graph's `retention.truncated`, HWA-31).
 // - Asks: open → answered (a reply) | declined | expired (at expiresAt, seen on read; expire() persists it).
 //   The first answer wins (version-checked write); later ones get `gone`.
 // - Replies and declines come only from the recipient (anyone else: not_found, like a foreign id) and go to
@@ -39,8 +40,11 @@ export const INBOX_RECENT = 50
 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 (design §3.3), recorded by the delivery engine. */
-export type Delivery = "steer" | "turn" | "queued" | "retained" | "pending"
+/**
+ * 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.
+ */
+export type Delivery = "steer" | "turn" | "queued" | "retained" | "pending" | "dropped"
 
 export interface Message {
   readonly id: string
@@ -117,11 +121,18 @@ export interface Usage {
   readonly bytes: number
 }
 
+/** What the store retains (the interaction graph's retention disclosure, HWA-31). */
+export interface Retention extends Usage {
+  /** The newest `at` of a message the caps deleted; absent while nothing was evicted. */
+  readonly evictedAt?: number
+}
+
 const MESSAGES = "messages"
 const INDEX = "message-index"
 const USAGE = "message-usage"
 const MUTES = "message-mutes"
 const USAGE_KEY = "total"
+const EVICTED_KEY = "evicted"
 /** Version-checked attempts to detach a contended message. */
 const DETACH_ATTEMPTS = 16
 
@@ -261,6 +272,18 @@ export class Messages {
     return (await this.state.get<Usage>(userID, USAGE, USAGE_KEY))?.value ?? { count: 0, bytes: 0 }
   }
 
+  /** Every retained message of the user, oldest first, as of now: one scan, for whole-user projections. */
+  async all(userID: string): Promise<Message[]> {
+    const entries = await this.state.list<StoredMessage>(userID, MESSAGES)
+    return entries.map((entry) => this.view(entry.value.message)).sort((a, b) => a.at - b.at || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+  }
+
+  /** Usage and the newest evicted message's time (older interactions may be missing). */
+  async retention(userID: string): Promise<Retention> {
+    const [usage, evicted] = await Promise.all([this.usage(userID), this.state.get<number>(userID, USAGE, EVICTED_KEY)])
+    return { ...usage, ...(evicted ? { evictedAt: evicted.value } : {}) }
+  }
+
   /** Records how the message was delivered; undefined when there is no such message. */
   async setDelivery(userID: string, id: string, delivery: Delivery): Promise<Message | undefined> {
     const at = this.now()
@@ -431,6 +454,8 @@ export class Messages {
         if ((await this.state.put<StoredMessage>(userID, MESSAGES, id, { ...current.value, indexed }, { ifVersion: current.version })).ok) return
       } else if ((await this.state.delete(userID, MESSAGES, id, { ifVersion: current.version })).ok) {
         await this.addUsage(userID, -1, -current.value.bytes)
+        const at = current.value.message.at
+        await updateVersioned<number>(this.state, userID, USAGE, EVICTED_KEY, (marked) => (marked !== undefined && marked >= at ? undefined : at))
         return
       }
     }

package/src/central/agent/names.ts

@@ -4,7 +4,7 @@
 
 import { NAME_MAX, validName } from "../../../packages/sdk/src/address.ts"
 
-export { NAME_MAX, parseAddress, validName, type Address } from "../../../packages/sdk/src/address.ts"
+export { addressProblem, NAME_MAX, parseAddress, validName, type Address, type AddressProblem } from "../../../packages/sdk/src/address.ts"
 
 /**
  * OpenCode's fallback titles: "New session" / "Child session" (display labels) and the historical
@@ -43,10 +43,20 @@ export function withSuffix(base: string, taken: (name: string) => boolean): stri
 export const isReservedName = (name: string): boolean => name === "me"
 
 /** Roles only the user may claim in phase 1 (grants including `roles` come in phase 3). */
-const RESERVED_ROLES = ["orchestrator"]
+const RESERVED_ROLES = ["orchestrator", "concierge"]
 
 export const isReservedRole = (role: string): boolean => RESERVED_ROLES.some((prefix) => role.startsWith(prefix))
 
+/**
+ * (CON-04) Roles only the hub itself claims and releases (reserved too): not the user, a session, an app under a
+ * `roles` grant or a launch spec. `concierge`: the Concierge service holds it for the user's current Concierge.
+ */
+const MANAGED_ROLES = ["concierge"]
+
+export const isManagedRole = (role: string): boolean => MANAGED_ROLES.some((prefix) => role.startsWith(prefix))
+
+export const MANAGED_ROLE_MESSAGE = (role: string) => `@@${role} is managed by the hub: use Settings → Concierge`
+
 /** The longest derived name: a few words, short enough to type and read in an address (@send-hello-to-session). */
 export const DERIVED_NAME_MAX = 24
 /** At most this many words of the title make a derived name. */

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

@@ -3,12 +3,14 @@
 //
 // Routes (user actors always; session tokens and app tokens holding sessions:read):
 //   GET /api/agent/status
-//   GET /api/agent/sessions?project=&state=&machine=&label=k=v
+//   GET /api/agent/sessions?project=&state=&machine=&label=k=v&q=   (CON-11) q: every word in the title or @name
 //   GET /api/agent/sessions/:addr          show: the catalog view plus the spoke's summary (when it serves one)
 //   GET /api/agent/sessions/:addr/log?n=20 the newest timeline rows (spoke feature "timeline")
 //   GET /api/agent/watch?blocked=1&session=<addr>  SSE of compact events (watch.ts)
 // show and log call spokes; a spoke without the feature answers unsupported {feature, harness}.
 // A session a launch started carries that launch's labels (the latest launch's, when several did); others have none.
+// (CON-02) /sessions and /sessions/:addr entries carry `intent {text, source, revision}` when one is stored (untrusted
+// text; the title fallback is only on GET /sessions/:addr/intent, intent-routes.ts).
 import path from "node:path"
 import { featureForOp, type ServerRequest, type SpokeFeature } from "../../protocol"
 import type { CatalogMachine, CatalogSession, LiveStatus, NowActivity, RegistryMessage, SessionView } from "../registry"
@@ -21,9 +23,14 @@ import { AgentError } from "./errors"
 import { AGENT_PREFIX, type AgentRoute } from "./routes"
 import { watchStream } from "./watch"
 import type { EventsRouteDeps } from "./events-routes"
+import { type Census, type TeamDiscovery, visible } from "../teams/discovery"
+import type { SessionIntent } from "../../protocol"
+import { intentField } from "./intents"
 
 /** Labels per session ID. */
 export type SessionLabels = ReadonlyMap<string, Readonly<Record<string, string>>>
+/** (CON-02) Stored intents per session ID. */
+export type SessionIntentMap = ReadonlyMap<string, SessionIntent>
 
 /** What the read routes need from the Registry. */
 export interface ReadRegistry {
@@ -32,6 +39,8 @@ export interface ReadRegistry {
   session(sessionID: string): SessionView | undefined
   owner(sessionID: string): string | undefined
   supports(connID: string, feature: SpokeFeature): boolean
+  /** (RP-08) A connection's harness (Registry implements it). */
+  harnessOf?(connID: string): string | undefined
   subscribe(listener: (message: RegistryMessage, tenant?: string) => void): () => void
 }
 
@@ -47,6 +56,8 @@ export interface ReadDeps {
   readonly spokes?: SpokeRequester
   /** The labels of the user's launched sessions (none without it). */
   readonly labels?: (userID: string) => Promise<SessionLabels>
+  /** (CON-02) The stored intents of these sessions: GET /sessions and /sessions/:addr carry `intent` when present. */
+  readonly intents?: (userID: string, sessionIDs: readonly string[]) => Promise<SessionIntentMap>
   /** The journal GET /api/agent/watch streams (no watch route without it). */
   readonly events?: EventsRouteDeps
   /** Watch stream heartbeat (default WATCH_HEARTBEAT_MS). */
@@ -54,6 +65,10 @@ export interface ReadDeps {
   /** Aborted when the hub drains: watch streams end with a `retry:` hint. */
   readonly draining?: AbortSignal
   readonly now?: () => number
+  /** Team-aware discovery (HWA-40): team members see their teams; invisible sessions read as unknown. */
+  readonly discovery?: TeamDiscovery
+  /** (CON-04) The user's Concierge sessions (current and hidden): their entries carry `concierge: true`. */
+  readonly concierge?: (userID: string) => Promise<readonly string[]>
 }
 
 /** One session in agent answers (status, sessions). */
@@ -168,8 +183,9 @@ function you(actor: AgentActor, entries: Map<string, DirectoryEntry>) {
 }
 
 /** The status snapshot of one user (design §4): machines → projects → sessions, and what needs attention. */
-export function snapshot(deps: ReadDeps, userID: string, actor: AgentActor, labels: SessionLabels = NO_LABELS) {
-  const list = rows(deps.registry, userID)
+export function snapshot(deps: ReadDeps, userID: string, actor: AgentActor, labels: SessionLabels = NO_LABELS, census?: Census, exclude: ReadonlySet<string> = NONE) {
+  const list = rows(deps.registry, userID).filter((r) => (!census || visible(census, r.session.id)) && !exclude.has(r.session.id))
+  const teams = census && deps.discovery ? deps.discovery.groups(census, list.map((r) => r.session.id)) : []
   const entries = directoryOf(deps.directory, userID)
   const online = new Map(deps.registry.catalog().map((m) => [m.id, m]))
   const machines = deps.store
@@ -193,12 +209,12 @@ export function snapshot(deps: ReadDeps, userID: string, actor: AgentActor, labe
         projects: [...projects.values()],
       }
     })
-  return { at: (deps.now ?? Date.now)(), you: you(actor, entries), machines, attention: attention(list, entries) }
+  return { at: (deps.now ?? Date.now)(), you: you(actor, entries), machines, attention: attention(list, entries), ...(teams.length ? { teams } : {}) }
 }
 
 /** The session an address names for the user, if the user's spokes report it now (else offline). */
-function located(deps: ReadDeps, userID: string, addr: string) {
-  const entry = deps.directory.resolveOne(userID, addr)
+function located(deps: ReadDeps, userID: string, addr: string, census?: Census) {
+  const entry = census && deps.discovery ? deps.discovery.resolveOne(census, addr) : deps.directory.resolveOne(userID, addr)
   const live = deps.registry.sessionTenant(entry.sessionID) === userID ? deps.registry.session(entry.sessionID) : undefined
   const list = rows(deps.registry, userID)
   const row = list.find((r) => r.session.id === entry.sessionID) ?? (live && list.find((r) => r.session.id === live.status[0]?.id))
@@ -226,9 +242,13 @@ async function ask(deps: ReadDeps, connID: string, req: ServerRequest): Promise<
 }
 
 /** GET /sessions/:addr: the session's catalog view with full blockers, and its summary from the spoke. */
-async function show(deps: ReadDeps, userID: string, addr: string) {
-  const { entry, live, row } = located(deps, userID, addr)
+async function show(deps: ReadDeps, userID: string, addr: string, census?: Census) {
+  const { entry, live, row } = located(deps, userID, addr, census)
+  const memberships = census && deps.discovery ? deps.discovery.memberships(census, entry.sessionID) : []
+  const teams = memberships.length ? { teams: memberships } : {}
   const labels = { ...(await labelsOf(deps, userID)).get(entry.sessionID) }
+  const intent = intentField((await intentsOf(deps, userID, [entry.sessionID])).get(entry.sessionID))
+  const marker = (await conciergeOf(deps, userID)).has(entry.sessionID) ? { concierge: true } : {}
   const name = entry.name ? { name: `@${entry.name}` } : {}
   const roles = entry.roles.map(roleLabel)
   if (!live) {
@@ -245,6 +265,9 @@ async function show(deps: ReadDeps, userID: string, addr: string) {
       ...(entry.lastSeen !== undefined ? { lastSeen: entry.lastSeen } : {}),
       blockers: [],
       labels,
+      ...intent,
+      ...marker,
+      ...teams,
     }
   }
   const harness = row?.harness ?? "unknown"
@@ -266,6 +289,9 @@ async function show(deps: ReadDeps, userID: string, addr: string) {
     blockers: live.blockers.map(({ sessionTitle: _, ...b }) => b),
     children: live.status.filter((e) => e.parentID === live.id).length,
     labels,
+    ...intent,
+    ...marker,
+    ...teams,
   }
   try {
     const connID = spokeFor(deps, live.id, "summary", harness)
@@ -279,23 +305,53 @@ async function show(deps: ReadDeps, userID: string, addr: string) {
 }
 
 /** GET /sessions/:addr/log: the newest `n` timeline rows, newest first. */
-async function log(deps: ReadDeps, userID: string, addr: string, raw: string | null) {
+async function log(deps: ReadDeps, userID: string, addr: string, raw: string | null, census?: Census) {
   const n = raw === null ? 20 : Number(raw)
   if (!Number.isInteger(n) || n < 1 || n > 200) throw new AgentError("invalid", "n must be 1–200")
-  const { entry, live, row } = located(deps, userID, addr)
+  const { entry, live, row } = located(deps, userID, addr, census)
   if (!live) throw new AgentError("offline", "No spoke reports this session now")
   const connID = spokeFor(deps, entry.sessionID, "timeline", row?.harness ?? "unknown")
   const page = (await ask(deps, connID, { op: "timeline", sessionID: entry.sessionID, limit: n, order: "desc" })) as { items?: unknown[]; older?: string }
   return { sessionID: entry.sessionID, rows: page.items ?? [], ...(page.older ? { older: page.older } : {}) }
 }
 
+const censusOf = (deps: ReadDeps, userID: string, actor: AgentActor): Promise<Census | undefined> => deps.discovery?.census(userID, actor) ?? Promise.resolve(undefined)
+
 const labelsOf = (deps: ReadDeps, userID: string): Promise<SessionLabels> => deps.labels?.(userID) ?? Promise.resolve(NO_LABELS)
 
+const NO_INTENTS: SessionIntentMap = new Map()
+/** (CON-04) The user's Concierge sessions (none without the dep). */
+async function conciergeOf(deps: ReadDeps, userID: string): Promise<ReadonlySet<string>> {
+  return new Set(deps.concierge ? await deps.concierge(userID) : [])
+}
+
+const NONE: ReadonlySet<string> = new Set()
+/**
+ * (CON-09a) What a Concierge session's own reads leave out: every Concierge session (current and previous), so it
+ * never reports itself as one of the user's sessions ("Greeting is working"). Anyone else: nothing.
+ */
+export async function conciergeSelf(concierge: ((userID: string) => Promise<readonly string[]>) | undefined, userID: string, actor: AgentActor): Promise<ReadonlySet<string>> {
+  if (actor.kind !== "session" || !concierge) return NONE
+  const all = new Set(await concierge(userID))
+  return all.has(actor.sessionID) ? all : NONE
+}
+
+const intentsOf = (deps: ReadDeps, userID: string, sessionIDs: readonly string[]): Promise<SessionIntentMap> =>
+  deps.intents && sessionIDs.length ? deps.intents(userID, sessionIDs) : Promise.resolve(NO_INTENTS)
+
 const STATES = new Set(["idle", "working", "blocked", "error"])
 
 /** The /sessions filters: project (name or root), state (comma list), machine (ID or name), label k=v. */
+/** (CON-11) The longest `q` (characters). */
+const QUERY_MAX = 200
+/** Search words: lower case, letters and digits only (an @, dashes and punctuation separate words). */
+const words = (text: string) => text.toLowerCase().normalize("NFKD").replace(/\p{M}/gu, "").split(/[^\p{L}\p{N}]+/u).filter(Boolean)
+
 function sessionFilter(deps: ReadDeps, userID: string, params: URLSearchParams): (row: Row, view: AgentSessionView) => boolean {
   const project = params.get("project") || undefined
+  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)
   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
@@ -310,6 +366,10 @@ function sessionFilter(deps: ReadDeps, userID: string, params: URLSearchParams):
     if (project !== undefined && root !== project && name.toLowerCase() !== project.toLowerCase()) return false
     if (states?.length && !states.includes(view.state)) return false
     if (machineIDs && !machineIDs.has(row.machineID)) return false
+    if (wanted.length) {
+      const have = [...words(view.title ?? ""), ...words(view.name ?? "")]
+      if (!wanted.every((w) => have.some((h) => h.includes(w)))) return false
+    }
     return labels.every(([key, value]) => view.labels[key] === value)
   }
 }
@@ -324,20 +384,25 @@ export function readRoutes(deps: ReadDeps): AgentRoute[] {
       method: "GET",
       path: `${AGENT_PREFIX}/status`,
       allow: READ,
-      handle: async ({ user, actor }) => ok(snapshot(deps, user.id, actor, await labelsOf(deps, user.id))),
+      handle: async ({ user, actor }) => ok(snapshot(deps, user.id, actor, await labelsOf(deps, user.id), await censusOf(deps, user.id, actor), await conciergeSelf(deps.concierge, user.id, actor))),
     },
     {
       method: "GET",
       path: `${AGENT_PREFIX}/sessions`,
       allow: READ,
-      handle: async ({ user, url }) => {
+      handle: async ({ user, url, actor }) => {
         const keep = sessionFilter(deps, user.id, url.searchParams)
+        const census = await censusOf(deps, user.id, actor)
         const entries = directoryOf(deps.directory, user.id)
         const labels = await labelsOf(deps, user.id)
-        const sessions = rows(deps.registry, user.id)
+        const self = await conciergeSelf(deps.concierge, user.id, actor)
+        const listed = rows(deps.registry, user.id)
           .map((row) => ({ row, view: view(row, entries.get(row.session.id), labels) }))
-          .filter(({ row, view }) => keep(row, view))
-          .map(({ row, view }) => ({ ...view, machineID: row.machineID, project: projectOf(row.session).name }))
+          .filter(({ row, view }) => keep(row, view) && (!census || visible(census, row.session.id)) && !self.has(row.session.id))
+        // Only the listed sessions' intents are read (never the whole collection).
+        const intents = await intentsOf(deps, user.id, listed.map(({ row }) => row.session.id))
+        const concierge = await conciergeOf(deps, user.id)
+        const sessions = listed.map(({ row, view }) => ({ ...view, machineID: row.machineID, project: projectOf(row.session).name, ...intentField(intents.get(row.session.id)), ...(concierge.has(row.session.id) ? { concierge: true } : {}) }))
         return ok({ sessions })
       },
     },
@@ -345,13 +410,13 @@ export function readRoutes(deps: ReadDeps): AgentRoute[] {
       method: "GET",
       path: `${AGENT_PREFIX}/sessions/:addr`,
       allow: READ,
-      handle: async ({ user, params }) => ok(await show(deps, user.id, params.addr!)),
+      handle: async ({ user, params, actor }) => ok(await show(deps, user.id, params.addr!, await censusOf(deps, user.id, actor))),
     },
     {
       method: "GET",
       path: `${AGENT_PREFIX}/sessions/:addr/log`,
       allow: READ,
-      handle: async ({ user, params, url }) => ok(await log(deps, user.id, params.addr!, url.searchParams.get("n"))),
+      handle: async ({ user, params, url, actor }) => ok(await log(deps, user.id, params.addr!, url.searchParams.get("n"), await censusOf(deps, user.id, actor))),
     },
     ...(deps.events ? [watchRoute(deps, deps.events)] : []),
   ]
@@ -363,9 +428,11 @@ function watchRoute(deps: ReadDeps, events: EventsRouteDeps): AgentRoute {
     method: "GET",
     path: `${AGENT_PREFIX}/watch`,
     allow: READ,
-    handle: ({ user, url, request, actor }) => {
+    handle: async ({ user, url, request, actor }) => {
       const addr = url.searchParams.get("session") || undefined
-      const sessions = addr ? new Set(deps.directory.resolve(user.id, addr).sessions.map((s) => s.sessionID)) : undefined
+      const census = addr ? await censusOf(deps, user.id, actor) : undefined
+      const resolved = addr ? (census && deps.discovery ? deps.discovery.resolve(census, addr) : deps.directory.resolve(user.id, addr)) : undefined
+      const sessions = resolved ? new Set(resolved.sessions.map((s) => s.sessionID)) : undefined
       const blocked = ["1", "true"].includes(url.searchParams.get("blocked") ?? "")
       const cursor = url.searchParams.get("cursor") || request.headers.get("last-event-id") || undefined
       return watchStream({