@huynle/hub 0.7.4 → 0.8.1

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,55 @@ 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)
+  // (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
@@ -306,10 +364,15 @@ 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
     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 +387,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 +413,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 +431,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({

package/src/central/agent/routes.ts

@@ -8,7 +8,7 @@
 // Path parameters address sessions as `:addr` (resolved per caller), never `:session`.
 import type { AgentEvents } from "./events"
 import type { CursorKeys } from "./event-cursor"
-import { eventsRoutes } from "./events-routes"
+import { eventsRoutes, type EventsRouteDeps } from "./events-routes"
 import type { DeviceRecord, Store, UserRecord } from "../store"
 import type { Directory } from "./directory"
 import { directoryRoutes } from "./directory-routes"
@@ -30,6 +30,36 @@ import { actingRoutes } from "./acting-routes"
 import type { Actions } from "../actions"
 import { launchRoutes, type RouteLaunches } from "./launch-routes"
 import { type RouteWebhooks, webhookRoutes } from "./webhook-routes"
+import { pinAuthorizer } from "../profiles/apply"
+import { profileRoutes } from "../profiles/routes"
+import { ProfileUsage } from "../profiles/usage"
+import { usagePorts } from "../profiles/usage-ports"
+import type { ProfileStore } from "../profiles/store"
+import { workspaceRoutes, type WorkspaceRoutesDeps } from "../workspaces/routes"
+import { boardRoutes, registryBoardSessions } from "../workspaces/board"
+import { type CheckpointStore, checkpointRoutes } from "../workspaces/checkpoints"
+import { masterRoutes } from "../workspaces/master"
+import { routePorts, sideChatRoutes } from "../workspaces/sidechats-routes"
+import { type ArtifactRouteDeps, artifactRoutes } from "../artifacts/routes"
+import { artifactJobRoutes, jobPorts } from "../artifacts/jobs-routes"
+import { type ArtifactHostRouteDeps, artifactHostRoutes } from "../artifacts/host"
+import { type GraphRouteDeps, graphRoutes } from "./interaction-graph-routes"
+import type { TeamIntakeService } from "../teams/intake"
+import { intakeRoutes } from "../teams/intake-routes"
+import { eventVisibility, type TeamDiscovery } from "../teams/discovery"
+import { teamRoutes, type TeamRoutesDeps } from "../teams/routes"
+import type { StateStore } from "../backend/types"
+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, type MachineModel } from "../concierge/routes"
+import { guardConciergeRoutes } from "../concierge/guard"
+import { isConciergeLaunch } from "../concierge/supervisor"
+import type { ConciergeService } from "../concierge/service"
+import type { SessionIntent } from "../../protocol"
+import type { SessionIntents } from "./intents"
+import { intentRoutes } from "./intent-routes"
 
 export const AGENT_PREFIX = "/api/agent"
 
@@ -90,6 +120,22 @@ export interface AgentDeps {
   readonly launches?: RouteLaunches
   /** Webhooks (P4-T10): the /api/agent/webhooks routes when given. */
   readonly webhooks?: RouteWebhooks
+  /** Profiles (HWA-14): the /api/agent/profiles and /sessions/:addr/profile routes when given with the directory. */
+  readonly profiles?: ProfileStore
+  /** Workspaces (HWA-06): the /api/agent/workspaces routes when given. */
+  readonly workspaces?: Pick<WorkspaceRoutesDeps, "workspaces" | "members" | "supervision" | "lifecycle">
+  /** Supervisor checkpoints (HWA-11): POST/GET /api/agent/workspaces/:id/checkpoints when given. */
+  readonly workspaceCheckpoints?: CheckpointStore
+  /** Team intake (HWA-36): /api/agent/teams/:id/intake when given. */
+  readonly teamIntake?: TeamIntakeService
+  /** Teams (HWA-37): /api/agent/teams definitions, staffing and status when given (the hub's single instances). */
+  readonly teams?: Pick<TeamRoutesDeps, "teams" | "seats" | "staffing">
+  /** Persistent artifacts (HWA-21): /api/agent/artifacts; without a store the routes answer 422 unsupported. */
+  readonly artifacts?: ArtifactRouteDeps
+  /** Isolated artifact host (HWA-26): mint/revoke capability URLs for html/app revisions when given. */
+  readonly artifactHost?: ArtifactHostRouteDeps
+  /** Interaction graph (HWA-31) team overlay; the graph routes are added with the directory, registry and delivery. */
+  readonly graph?: Pick<GraphRouteDeps, "teams">
   /** The canonical agent event journal: archive changes are appended to it. */
   readonly agentEvents?: Pick<AgentEvents, "append" | "latest" | "since" | "appended">
   /** Signing keys of GET /api/agent/events cursors; the events route is served when given with agentEvents. */
@@ -105,6 +151,34 @@ export interface AgentDeps {
   /** Aborted when the hub drains: watch streams end with a `retry:` hint. */
   readonly draining?: AbortSignal
   readonly now?: () => number
+  /** Team-aware discovery (HWA-40): who and the read routes scope team members to their teams. */
+  readonly teamDiscovery?: TeamDiscovery
+  /**
+   * Concierge (CON-01): the /api/agent/concierge/watchlist routes when given with the directory and registry.
+   * `identity` is the user's current Concierge session (CON-04); without it no session token is admitted.
+   */
+  readonly concierge?: {
+    readonly state: StateStore
+    readonly activity: Pick<ActivityTracker, "list">
+    readonly identity?: ConciergeIdentity
+    readonly results?: Pick<ResultTracker, "many">
+    /** (CON-04) Sessions only the user acts on (the Concierge's): the act verbs refuse agents on them. */
+    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). */
+    readonly armed?: (userID: string) => Promise<string | undefined>
+    /** (CON-10) The user's time zone (Concierge settings): the rendered board's time is local. */
+    readonly timeZone?: (userID: string) => Promise<string | undefined>
+    /** (CON-13) The board's inGrant (board-routes.ts BoardRouteDeps.coverage). */
+    readonly coverage?: (userID: string, conciergeSessionID: string, sessionID: string, requestID: string) => Promise<{ readonly inGrant: boolean; readonly auto: boolean }>
+  }
+  /** (CON-02) Session intents: GET/PUT /api/agent/sessions/:addr/intent with the directory; reads carry `intent`. */
+  readonly intents?: SessionIntents
 }
 
 /**
@@ -125,11 +199,12 @@ const userView = (user: UserRecord) => ({
 /** The built-in /api/agent routes. */
 export function agentRoutes(deps: AgentDeps): AgentRoute[] {
   const feed = deps.feed ?? new MessageFeed()
-  return [
-    ...(deps.directory ? directoryRoutes({ directory: deps.directory, store: deps.store, ...(deps.agentEvents ? { events: deps.agentEvents } : {}), ...(deps.registry ? { registry: deps.registry } : {}), ...(deps.grants ? { grants: deps.grants } : {}), ...(deps.acting ? { acting: deps.acting } : {}), ...(deps.audit ? { audit: deps.audit } : {}), ...(deps.eventCursorKeys ? { previewKeys: deps.eventCursorKeys } : {}) }) : []),
-    ...(deps.directory && deps.agentEvents && deps.eventCursorKeys ? eventsRoutes({ events: deps.agentEvents, keys: deps.eventCursorKeys, directory: deps.directory }) : []),
+  const routes: AgentRoute[] = [
+    ...(deps.directory ? directoryRoutes({ directory: deps.directory, store: deps.store, ...(deps.agentEvents ? { events: deps.agentEvents } : {}), ...(deps.registry ? { registry: deps.registry } : {}), ...(deps.grants ? { grants: deps.grants } : {}), ...(deps.acting ? { acting: deps.acting } : {}), ...(deps.audit ? { audit: deps.audit } : {}), ...(deps.eventCursorKeys ? { previewKeys: deps.eventCursorKeys } : {}), ...(deps.teamDiscovery ? { discovery: deps.teamDiscovery } : {}), ...intentReads(deps), ...conciergeReads(deps) }) : []),
+    ...(deps.directory && deps.intents ? intentRoutes({ intents: deps.intents, directory: deps.directory, store: deps.store, ...(deps.registry ? { registry: deps.registry } : {}), ...(deps.teamDiscovery ? { discovery: deps.teamDiscovery } : {}) }) : []),
+    ...(deps.directory && deps.agentEvents && deps.eventCursorKeys ? eventsRoutes({ events: deps.agentEvents, keys: deps.eventCursorKeys, directory: deps.directory, ...eventScope(deps) }) : []),
     ...(deps.directory && deps.delivery ? messageRoutes({ delivery: deps.delivery, directory: deps.directory, store: deps.store, feed, ...(deps.decisions ? { decisions: deps.decisions } : {}) }) : []),
-    ...(deps.directory && deps.registry ? readRoutes({ store: deps.store, directory: deps.directory, registry: deps.registry, ...(deps.spokes ? { spokes: deps.spokes } : {}), ...launchReads(deps), ...(deps.agentEvents && deps.eventCursorKeys ? { events: { events: deps.agentEvents, keys: deps.eventCursorKeys, directory: deps.directory } } : {}), ...(deps.heartbeatMs !== undefined ? { heartbeatMs: deps.heartbeatMs } : {}), ...(deps.now ? { now: deps.now } : {}), ...(deps.draining ? { draining: deps.draining } : {}) }) : []),
+    ...(deps.directory && deps.registry ? readRoutes({ store: deps.store, directory: deps.directory, registry: deps.registry, ...(deps.spokes ? { spokes: deps.spokes } : {}), ...launchReads(deps), ...(deps.agentEvents && deps.eventCursorKeys ? { events: { events: deps.agentEvents, keys: deps.eventCursorKeys, directory: deps.directory, ...eventScope(deps) } } : {}), ...(deps.heartbeatMs !== undefined ? { heartbeatMs: deps.heartbeatMs } : {}), ...(deps.now ? { now: deps.now } : {}), ...(deps.draining ? { draining: deps.draining } : {}), ...(deps.teamDiscovery ? { discovery: deps.teamDiscovery } : {}), ...intentReads(deps), ...conciergeReads(deps) }) : []),
     {
       method: "GET",
       path: `${AGENT_PREFIX}/whoami`,
@@ -145,7 +220,83 @@ export function agentRoutes(deps: AgentDeps): AgentRoute[] {
       ? launchRoutes({ launches: deps.launches, grants: deps.grants, acting: deps.acting, audit: deps.audit, ...(deps.directory ? { directory: deps.directory } : {}) })
       : []),
     ...(deps.webhooks ? webhookRoutes(deps.webhooks, deps.store) : []),
+    ...(deps.profiles && deps.directory
+      ? profileRoutes({
+          profiles: deps.profiles,
+          directory: deps.directory,
+          audit: deps.store,
+          ...(deps.agentEvents ? { events: deps.agentEvents } : {}),
+          // HWA-15: an app's pin also needs a usable prompt grant on the session.
+          ...(deps.grants && deps.registry ? { authorizePin: pinAuthorizer({ registry: deps.registry, grants: deps.grants, ...(deps.acting ? { acting: deps.acting } : {}) }) } : {}),
+          // RP-08: where a profile is used (pins, team roles, launches, workspaces).
+          usage: new ProfileUsage({
+            profiles: deps.profiles,
+            ports: usagePorts({
+              directory: deps.directory,
+              ...(deps.registry ? { registry: deps.registry } : {}),
+              ...(deps.teams ? { teams: { teams: deps.teams.teams, seats: deps.teams.seats } } : {}),
+              ...(deps.launches ? { launches: deps.launches } : {}),
+              ...(deps.workspaces ? { workspaces: { workspaces: deps.workspaces.workspaces, members: deps.workspaces.members } } : {}),
+            }),
+          }),
+        })
+      : []),
+    ...(deps.workspaces ? workspaceRoutes({ ...deps.workspaces, audit: deps.store, ...(deps.agentEvents ? { events: deps.agentEvents } : {}) }) : []),
+    ...(deps.workspaces ? boardRoutes({ ...deps.workspaces, ...(deps.directory && deps.registry ? { sessions: registryBoardSessions(deps.directory, deps.registry) } : {}), ...(deps.decisions ? { decisions: deps.decisions } : {}), ...(deps.artifacts?.artifacts ? { artifacts: deps.artifacts.artifacts } : {}), ...(deps.now ? { now: deps.now } : {}) }) : []),
+    ...(deps.workspaceCheckpoints ? checkpointRoutes({ checkpoints: deps.workspaceCheckpoints, audit: deps.store }) : []),
+    ...(deps.workspaces ? masterRoutes({ ...deps.workspaces, audit: deps.store, ...(deps.workspaceCheckpoints ? { checkpoints: deps.workspaceCheckpoints } : {}), ...(deps.launches ? { launches: deps.launches } : {}), ...(deps.agentEvents ? { events: deps.agentEvents } : {}), ...(deps.now ? { now: deps.now } : {}) }) : []),
+    ...artifactRoutes(deps.artifacts ?? {}),
+    ...(deps.artifactHost ? artifactHostRoutes(deps.artifactHost) : []),
+    ...(deps.directory && deps.registry && deps.delivery ? graphRoutes({ store: deps.store, registry: deps.registry, directory: deps.directory, messages: deps.delivery.messages, ...(deps.decisions ? { decisions: deps.decisions } : {}), ...(deps.launches ? { launches: deps.launches } : {}), ...(deps.workspaces ? { workspaces: deps.workspaces } : {}), ...(deps.audit ? { audit: deps.audit } : {}), ...deps.graph, ...(deps.now ? { now: deps.now } : {}), ...conciergeReads(deps), ...conciergeCurrent(deps) }) : []),
+    ...(deps.teamIntake ? intakeRoutes({ intake: deps.teamIntake, audit: deps.store }) : []),
+    ...(deps.teams ? teamRoutes({ ...deps.teams, ...(deps.teamIntake ? { intake: deps.teamIntake } : {}), audit: deps.store, ...(deps.agentEvents ? { events: deps.agentEvents } : {}) }) : []),
+    ...(deps.concierge && deps.directory && deps.registry
+      ? watchlistRoutes({ ...deps.concierge, directory: deps.directory, store: deps.store, registry: deps.registry, ...(deps.decisions ? { decisions: deps.decisions } : {}), ...launchReads(deps), ...(deps.agentEvents ? { events: deps.agentEvents } : {}), ...(deps.now ? { now: deps.now } : {}) })
+      : []),
+    // CON-03: the situation board and the Concierge's Decision reads (users and the current Concierge only).
+    ...(deps.concierge && deps.directory && deps.registry
+      ? 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.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.
+  const { registry } = deps
+  const sourceUpdatedAt = registry ? (userID: string, id: string) => (registry.sessionTenant(id) === userID ? registry.session(id)?.updated : undefined) : undefined
+  // HWA-24: artifact AI jobs start their handler through the launch and message routes above, as the requester.
+  const a = deps.artifacts
+  routes.push(...artifactJobRoutes({ ...(a?.artifacts ? { artifacts: a.artifacts } : {}), ...(a?.state ? { state: a.state } : {}), ports: jobPorts(routes), ...(deps.launches ? { launches: deps.launches } : {}), audit: deps.store, ...(deps.agentEvents ? { events: deps.agentEvents } : {}), ...(deps.now ? { now: deps.now } : {}) }))
+  const all = deps.workspaces ? [...routes, ...sideChatRoutes({ workspaces: deps.workspaces.workspaces, ports: routePorts(routes), ...(deps.launches ? { launches: deps.launches } : {}), ...(sourceUpdatedAt ? { sourceUpdatedAt } : {}), audit: deps.store, ...(deps.agentEvents ? { events: deps.agentEvents } : {}), ...(deps.now ? { now: deps.now } : {}) })] : routes
+  // CON-04: manage paths never touch a Concierge session (concierge/guard.ts).
+  const identity = deps.concierge?.identity
+  const directory = deps.directory
+  const launches = deps.launches
+  return identity && directory
+    ? guardConciergeRoutes(all, {
+        identity,
+        resolve: (userID, addr) => directory.resolve(userID, addr).sessions.map((s) => s.sessionID),
+        ...(launches
+          ? {
+              launch: async (userID: string, id: string) => {
+                const l = await launches.view(userID, id)
+                return l ? { ...(l.sessionID !== undefined ? { sessionID: l.sessionID } : {}), concierge: isConciergeLaunch(l) } : undefined
+              },
+            }
+          : {}),
+      })
+    : all
+}
+
+/** HWA-28/40: unfiltered events and watch read by a team-scoped session leave out what discovery hides from it. */
+function eventScope(deps: AgentDeps): Pick<EventsRouteDeps, "scope" | "resolve"> {
+  const discovery = deps.teamDiscovery
+  return discovery
+    ? {
+        scope: async (userID, actor) => eventVisibility(await discovery.census(userID, actor)),
+        resolve: async (userID, actor, addr) => discovery.resolve(await discovery.census(userID, actor), addr).sessions.map((s) => s.sessionID),
+      }
+    : {}
 }
 
 /** What the read routes show of launches: launched sessions' labels (the latest launch wins). */
@@ -165,6 +316,24 @@ function launchReads(deps: AgentDeps): Pick<ReadDeps, "labels"> {
   }
 }
 
+/** (CON-04) Which sessions reads mark `concierge: true` (the user's current and hidden Concierge sessions). */
+function conciergeReads(deps: AgentDeps): { concierge?: (userID: string) => Promise<readonly string[]> } {
+  const identity = deps.concierge?.identity
+  return identity ? { concierge: async (userID: string) => (await identity.current(userID)).hiddenSessionIDs } : {}
+}
+
+/** (CON-09a) The user's current Concierge session (Watchtower labels it @@concierge). */
+function conciergeCurrent(deps: AgentDeps): { conciergeCurrent?: (userID: string) => Promise<string | undefined> } {
+  const identity = deps.concierge?.identity
+  return identity ? { conciergeCurrent: async (userID: string) => (await identity.current(userID)).sessionID } : {}
+}
+
+/** (CON-02) What reads show of intents: the stored ones of the listed sessions, by session. */
+function intentReads(deps: AgentDeps): { intents?: (userID: string, sessionIDs: readonly string[]) => Promise<Map<string, SessionIntent>> } {
+  const { intents } = deps
+  return intents ? { intents: (userID: string, sessionIDs: readonly string[]) => intents.many(userID, sessionIDs) } : {}
+}
+
 /** The act verbs, when every part they need is given. */
 function actVerbRoutes(deps: AgentDeps): AgentRoute[] {
   const { actions, acting, grants, audit, registry, directory, spokes } = deps
@@ -180,6 +349,7 @@ function actVerbRoutes(deps: AgentDeps): AgentRoute[] {
       audit,
       ...(deps.escalate ? { escalate: deps.escalate } : {}),
       ...(deps.maxPromptChars !== undefined ? { maxPromptChars: deps.maxPromptChars } : {}),
+      ...(deps.concierge?.protects ? { protect: deps.concierge.protects, conciergeActor: deps.concierge.protects } : {}),
     }),
   )
 }
@@ -192,6 +362,8 @@ export interface AgentApiOptions {
   /** Records activity of a resolved caller (device and user lastSeen). */
   touch?(user: UserRecord, device?: DeviceRecord): void
   readonly routes: readonly AgentRoute[]
+  /** Runs for every resolved caller before the route class check (CON-04: the Concierge's route allow-list). */
+  gate?(actor: AgentActor, route: AgentRoute): Promise<void>
 }
 
 export interface AgentApi {
@@ -250,6 +422,7 @@ export function agentApi(options: AgentApiOptions): AgentApi {
       options.touch?.(resolved.user, resolved.device)
       const found = find(method, url.pathname)
       if (!found) throw new AgentError("not_found", "Not found")
+      if (options.gate) await options.gate(resolved.actor, found.route)
       if (!agentAllows(found.route.allow, resolved.actor)) throw new AgentError("forbidden", "This credential cannot use this route")
       const { actor, credential, user, device } = resolved
       return await found.route.handle({ request, url, params: found.params, actor, credential, user, ...(device ? { device } : {}) })

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

@@ -9,6 +9,7 @@
 // scope of the only events so far, launch.*), which see and delete only the registrations they made and get only
 // the events of launches they started. Sessions cannot register webhooks. Another user's registration, or (apps)
 // one the token did not make, is 404 not_found.
+import { boundedJson } from "./body"
 import type { Store } from "../store"
 import type { AgentActor } from "./actor"
 import { AgentError } from "./errors"
@@ -37,7 +38,7 @@ const requireEventScopes = (actor: AgentActor, events: unknown) => {
 }
 
 async function bodyOf(request: Request): Promise<Record<string, unknown>> {
-  const raw = JSON.parse(await request.text()) as unknown
+  const raw = (await boundedJson(request)) as unknown
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new AgentError("invalid", "Body must be a JSON object")
   return raw as Record<string, unknown>
 }

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/agent-data.ts

@@ -38,6 +38,8 @@ export interface AgentSession {
   /** Project name (lowercased) used by `.project` scopes. */
   project?: string
   title?: string
+  /** The last harness kind a spoke reported it under (offline sessions keep their glyph, RF-02). */
+  harness?: string
   firstSeen?: number
   /** Last time a spoke reported it (ms; persisted at minute granularity while it stays online). */
   lastSeen?: number
@@ -70,6 +72,8 @@ export interface AgentData {
   generations?: Record<string, number>
   /** The user's agent kill switch (agent/acting-switch.ts): every agent action answers paused. */
   actingPaused?: true
+  /** (CON-09a) Sessions unnamed before the directory knew them: their record is never derived a name (≤ 500). */
+  unnamed?: string[]
   [field: string]: unknown
 }
 

package/src/central/artifacts/access.ts

@@ -0,0 +1,44 @@
+// Who may do what with an artifact (HWA-20; contract: Cross-cutting rules, Artifacts). Checked on every access by
+// the artifact store. Tenancy comes first: the store only ever reads the caller's own user's records, so another
+// user's artifact is simply missing. Within a user:
+// - The user (console, app token) owns every artifact: read, revise, manage.
+// - A session reads an artifact only when its visibility is "workspace" and the session is a *current* member of
+//   that workspace (re-checked on every read, so leaving a workspace ends access). It never reads a private one,
+//   even one it created: createdBySessionID is provenance and grants nothing.
+// - A session may create artifacts (they belong to its user). Membership grants no write: revising, metadata,
+//   visibility, archive and delete stay with the user unless an explicit grant-aware policy is passed in (the
+//   routes, HWA-21, may wire the existing grants through `authorize`).
+// Role labels and workspace roles never confer authority here.
+import type { Artifact } from "../../protocol"
+
+export type ArtifactPrincipal = { readonly kind: "user" } | { readonly kind: "session"; readonly sessionID: string }
+
+/** "manage": metadata, visibility, archive/unarchive and delete. */
+export type ArtifactAction = "read" | "create" | "revise" | "manage"
+
+/** The workspace facts access needs (HWA-03/04 provide them; tests use fixtures). */
+export interface ArtifactWorkspaces {
+  exists(userID: string, workspaceID: string): Promise<boolean>
+  isCurrentMember(userID: string, workspaceID: string, sessionID: string): Promise<boolean>
+}
+
+export interface AccessRequest {
+  readonly userID: string
+  readonly principal: ArtifactPrincipal
+  readonly action: ArtifactAction
+  /** Absent for create. */
+  readonly artifact?: Artifact
+  /** Absent when this hub has no workspaces: then no session reads through a workspace. */
+  readonly workspaces?: ArtifactWorkspaces
+}
+
+export type ArtifactAuthorizer = (request: AccessRequest) => Promise<boolean>
+
+/** The contract's default policy (see the header). */
+export const defaultArtifactPolicy: ArtifactAuthorizer = async ({ userID, principal, action, artifact, workspaces }) => {
+  if (principal.kind === "user") return true
+  if (action === "create") return true
+  if (action !== "read" || !artifact) return false
+  if (artifact.visibility !== "workspace" || artifact.workspaceID === undefined || !workspaces) return false
+  return workspaces.isCurrentMember(userID, artifact.workspaceID, principal.sessionID)
+}