From 4738cecc232263c22334e40c183993e4d16e4a89 Mon Sep 17 00:00:00 2001
From: mintaka <mintaka@rigel.build>
Date: Sat, 12 Sep 2026 10:32:39 -0400
Subject: [PATCH 1/2] feat(ui): mark each agent's runtime tier and egress
 posture
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The board showed lifecycle state only, so a host-tier agent — which shares the
host's network namespace and cannot be firewalled — looked exactly like a
contained one. Each agent now carries a marker naming its tier, and an
unenforced posture reads as uncontained on both colour and shape.

The session-status payload was subscribed but dropped, so this also lands the
decode: statuses key a runtime map by account id, which the roster join folds in
beside presence. A status with no resolvable account is skipped rather than
keyed under an empty id, and the map clears on resync — a stale posture
surviving a reset could show a torn-down session as still contained.

An absent marker stays absent rather than defaulting, because guessing a posture
is the one error this must not make.
---
 apps/ui/src/App.tsx                           |  4 +
 apps/ui/src/components/AgentView.tsx          |  4 +
 apps/ui/src/components/Bridge.tsx             |  7 ++
 apps/ui/src/components/LeftSidebar.tsx        |  2 +
 apps/ui/src/components/RightSidebar.tsx       | 10 ++-
 apps/ui/src/components/RuntimeMarker.tsx      | 39 +++++++++
 .../src/design/components/runtime-marker.css  | 29 +++++++
 apps/ui/src/live/adapt.test.ts                | 42 ++++++++++
 apps/ui/src/live/adapt.ts                     | 39 +++++++++
 apps/ui/src/live/events.test.ts               | 84 ++++++++++++++++++-
 apps/ui/src/live/events.ts                    | 28 ++++++-
 apps/ui/src/roster.test.ts                    | 32 ++++++-
 apps/ui/src/roster.ts                         | 12 ++-
 apps/ui/src/store.ts                          | 11 ++-
 apps/ui/src/stub-data.ts                      | 29 +++++++
 packages/compass-client/src/index.ts          |  3 +
 16 files changed, 366 insertions(+), 9 deletions(-)
 create mode 100644 apps/ui/src/components/RuntimeMarker.tsx
 create mode 100644 apps/ui/src/design/components/runtime-marker.css

diff --git a/apps/ui/src/App.tsx b/apps/ui/src/App.tsx
index fdc23d6da..972796f11 100644
--- a/apps/ui/src/App.tsx
+++ b/apps/ui/src/App.tsx
@@ -17,6 +17,7 @@ import {
 import { LeftSidebar } from "./components/LeftSidebar";
 import { Palette } from "./components/Palette";
 import { RightSidebar } from "./components/RightSidebar";
+import { RuntimeMarker } from "./components/RuntimeMarker";
 import { ShortcutsOverlay } from "./components/ShortcutsOverlay";
 import { StateDot } from "./components/StateDot";
 import { UsageBar } from "./components/UsageBar";
@@ -111,6 +112,9 @@ const App: Component<RouteSectionProps> = (props) => {
 								onClick={() => store.openAgent(agent().account.id)}
 							>
 								<StateDot state={agent().lifecycle ?? "idle"} />
+								<Show when={agent().runtime}>
+									{(m) => <RuntimeMarker marker={m()} />}
+								</Show>
 								{agent().account.displayName}
 							</button>
 						)}
diff --git a/apps/ui/src/components/AgentView.tsx b/apps/ui/src/components/AgentView.tsx
index e4ef67709..617aa61ad 100644
--- a/apps/ui/src/components/AgentView.tsx
+++ b/apps/ui/src/components/AgentView.tsx
@@ -10,6 +10,7 @@ import {
 import type { Agent, Terminal } from "../stub-data";
 import { ChannelView } from "./ChannelView";
 import { LogPanel } from "./LogPanel";
+import { RuntimeMarker } from "./RuntimeMarker";
 import { StateDot } from "./StateDot";
 
 /** A terminal pane: the fixture scrollback for the terminal a tab references. A
@@ -215,6 +216,9 @@ export const AgentView: Component = () => {
 				<div class="agent-view">
 					<div class="av-header">
 						<StateDot state={agent().lifecycle ?? "idle"} />
+						<Show when={agent().runtime}>
+							{(m) => <RuntimeMarker marker={m()} />}
+						</Show>
 						<span class="av-name">{agent().account.handle}</span>
 						<Show when={agent().model}>
 							<span class="av-model">{agent().model}</span>
diff --git a/apps/ui/src/components/Bridge.tsx b/apps/ui/src/components/Bridge.tsx
index 95746831d..b7651d240 100644
--- a/apps/ui/src/components/Bridge.tsx
+++ b/apps/ui/src/components/Bridge.tsx
@@ -41,6 +41,7 @@ import { createRovingGroup, type Stop } from "../keyboard/roving";
 import type { IssueState } from "../stub-data";
 import { BadgeGlyph } from "./BadgeGlyph";
 import { IssueCard } from "./IssueCard";
+import { RuntimeMarker } from "./RuntimeMarker";
 import { StateDot } from "./StateDot";
 
 /** How the board groups rows. Swimlane = one row per agent (default); status =
@@ -665,6 +666,9 @@ export const Bridge: Component = () => {
 											onClick={() => store.openAgent(agent.account.id)}
 										>
 											<StateDot state={agent.lifecycle ?? "idle"} />
+											<Show when={agent.runtime}>
+												{(m) => <RuntimeMarker marker={m()} />}
+											</Show>
 											<span>
 												<span class="g-name">{agent.account.handle}</span>
 												<br />
@@ -758,6 +762,9 @@ export const Bridge: Component = () => {
 												onClick={() => store.openAgent(agent().account.id)}
 											>
 												<StateDot state={agent().lifecycle ?? "idle"} />
+												<Show when={agent().runtime}>
+													{(m) => <RuntimeMarker marker={m()} />}
+												</Show>
 												<span class="g-name">{agent().account.handle}</span>
 												<span class="g-open" aria-hidden="true">
 													→
diff --git a/apps/ui/src/components/LeftSidebar.tsx b/apps/ui/src/components/LeftSidebar.tsx
index dc647c58d..7b8dc48e3 100644
--- a/apps/ui/src/components/LeftSidebar.tsx
+++ b/apps/ui/src/components/LeftSidebar.tsx
@@ -18,6 +18,7 @@ import { detectPlatform } from "../keyboard/dispatch";
 import { shortcutForAria } from "../keyboard/keymap";
 import { type Agent, type AgentTreeNode, agentTree } from "../stub-data";
 import { CoachTip, CoachTipContent, CoachTipTrigger } from "./CoachTip";
+import { RuntimeMarker } from "./RuntimeMarker";
 import { StateDot } from "./StateDot";
 
 /** An agent leaf row in the tree — the per-agent select button, plus a hover
@@ -46,6 +47,7 @@ const AgentLeaf: Component<{ agent: Agent; badge?: number }> = (props) => {
 				onClick={() => store.openAgent(a().account.id)}
 			>
 				<StateDot state={a().lifecycle ?? "idle"} />
+				<Show when={a().runtime}>{(m) => <RuntimeMarker marker={m()} />}</Show>
 				<span class="name">{a().account.handle}</span>
 				<Show when={a().role !== undefined && a().role !== "worker"}>
 					<span class="role-pip" data-role={a().role} title={a().role}>
diff --git a/apps/ui/src/components/RightSidebar.tsx b/apps/ui/src/components/RightSidebar.tsx
index 70275eb41..d5d5ced5d 100644
--- a/apps/ui/src/components/RightSidebar.tsx
+++ b/apps/ui/src/components/RightSidebar.tsx
@@ -27,6 +27,7 @@ import {
 	STUB_FILES,
 } from "../stub-data";
 import { ChannelView } from "./ChannelView";
+import { RuntimeMarker } from "./RuntimeMarker";
 import { StateDot } from "./StateDot";
 
 const FILE_ICON: Record<string, string> = { dir: "▸", file: "·" };
@@ -689,7 +690,14 @@ export const RightSidebar: Component = () => {
 													{tab.icon}
 												</span>
 												<Show when={agent()}>
-													{(a) => <StateDot state={a().lifecycle ?? "idle"} />}
+													{(a) => (
+														<>
+															<StateDot state={a().lifecycle ?? "idle"} />
+															<Show when={a().runtime}>
+																{(m) => <RuntimeMarker marker={m()} />}
+															</Show>
+														</>
+													)}
 												</Show>
 											</button>
 										);
diff --git a/apps/ui/src/components/RuntimeMarker.tsx b/apps/ui/src/components/RuntimeMarker.tsx
new file mode 100644
index 000000000..9e6eb1b9f
--- /dev/null
+++ b/apps/ui/src/components/RuntimeMarker.tsx
@@ -0,0 +1,39 @@
+import { type Component, Show } from "solid-js";
+import type { RuntimeMarker as RuntimeMarkerModel } from "../stub-data";
+import "../design/components/runtime-marker.css";
+
+/** The session runtime marker: a small mono text token beside the state dot
+ * naming which runner backend the session runs on (`podman` / `microvm` /
+ * `apple-container` / `host` / `unknown`). Where egress is `unenforced` the
+ * marker additionally reads as uncontained — a warn-colored `!` suffix plus a
+ * `data-uncontained` hook — so a user glancing at the roster can tell a
+ * host-network session from a contained one. An `unknown` tier or posture
+ * renders as such and never as contained. Color/sizing live in
+ * `runtime-marker.css`. */
+export const RuntimeMarker: Component<{ marker: RuntimeMarkerModel }> = (
+	props,
+) => {
+	const uncontained = () => props.marker.posture === "unenforced";
+	const label = () =>
+		`runtime ${props.marker.tier}, egress ${props.marker.posture}`;
+	return (
+		<span
+			class="cx-runtime-marker"
+			data-tier={props.marker.tier}
+			data-posture={props.marker.posture}
+			data-uncontained={uncontained() ? "1" : undefined}
+			title={label()}
+			// role="img" so the label replaces the glyphs for assistive tech: the
+			// bare tier text and the "!" do not say "egress unenforced" on their own.
+			role="img"
+			aria-label={label()}
+		>
+			{props.marker.tier}
+			<Show when={uncontained()}>
+				<span class="cx-runtime-uncontained" aria-hidden="true">
+					!
+				</span>
+			</Show>
+		</span>
+	);
+};
diff --git a/apps/ui/src/design/components/runtime-marker.css b/apps/ui/src/design/components/runtime-marker.css
new file mode 100644
index 000000000..ce8a022e5
--- /dev/null
+++ b/apps/ui/src/design/components/runtime-marker.css
@@ -0,0 +1,29 @@
+/* Runtime marker — .cx-runtime-marker[data-tier][data-posture]. A small mono
+   text token beside the state dot naming the session's runner backend. Rides
+   the low-emphasis meta color so it reads as metadata, not a live signal. An
+   uncontained (unenforced-egress) session flips to the warn color and shows a
+   `!` suffix so a host-network session is distinguishable at a glance; an
+   unknown tier/posture stays muted and never reads as contained. Consumes only
+   --cx-* tiers. */
+
+.cx-runtime-marker {
+	display: inline-flex;
+	align-items: center;
+	gap: 1px;
+	font-family: var(--cx-font-ui);
+	font-size: var(--cx-text-xs);
+	line-height: 1;
+	letter-spacing: 0.3px;
+	color: var(--cx-text-faint);
+}
+
+/* Uncontained egress (unenforced posture) — the one state a user must not read
+   as contained. Warn color + the `!` suffix carry it on both the color and the
+   shape axis, so it survives a monochrome or reduced-color view. */
+.cx-runtime-marker[data-uncontained="1"] {
+	color: var(--cx-warn);
+}
+
+.cx-runtime-uncontained {
+	font-weight: 700;
+}
diff --git a/apps/ui/src/live/adapt.test.ts b/apps/ui/src/live/adapt.test.ts
index 65f6b9ca1..747604d18 100644
--- a/apps/ui/src/live/adapt.test.ts
+++ b/apps/ui/src/live/adapt.test.ts
@@ -4,6 +4,7 @@ import {
 	AccountSchema,
 	AgentAccountSchema,
 	AgentPresence,
+	AgentSessionStatusSchema,
 	AskOptionSchema,
 	AskQuestionSchema,
 	AskSchema,
@@ -13,6 +14,7 @@ import {
 	ChannelPostPolicy,
 	ChannelSchema,
 	create,
+	EgressPosture,
 	ForgeProvider,
 	IssueSchema,
 	IssueState,
@@ -20,6 +22,7 @@ import {
 	MessageSchema,
 	PullRequestSchema,
 	RosterEntrySchema,
+	RuntimeTier,
 	SystemAccountSchema,
 	TopicSchema,
 	UserAccountSchema,
@@ -35,6 +38,7 @@ import {
 	adaptMessage,
 	adaptPullRequest,
 	adaptRosterEntry,
+	adaptRuntimeMarker,
 	adaptTopic,
 	agentHomeChannelIds,
 	deriveMembership,
@@ -1008,3 +1012,41 @@ describe("adaptRosterEntry", () => {
 		expect(info.lifecycle).toBeUndefined();
 	});
 });
+
+describe("adaptRuntimeMarker", () => {
+	// The runtime marker maps AgentSessionStatus.{runtime_tier,egress_posture}
+	// to the user-facing roster tokens. The semantics a user reads: a host tier
+	// with unenforced egress is the host backend AND visibly uncontained; a
+	// zero/unset value is unknown and never armed/contained.
+	test("host tier + unenforced egress maps to host and uncontained", () => {
+		const marker = adaptRuntimeMarker(
+			create(AgentSessionStatusSchema, {
+				runtimeTier: RuntimeTier.HOST,
+				egressPosture: EgressPosture.UNENFORCED,
+			}),
+		);
+		expect(marker.tier).toBe("host");
+		expect(marker.posture).toBe("unenforced");
+	});
+
+	test("a contained podman session reads as armed, not uncontained", () => {
+		const marker = adaptRuntimeMarker(
+			create(AgentSessionStatusSchema, {
+				runtimeTier: RuntimeTier.PODMAN,
+				egressPosture: EgressPosture.ARMED,
+			}),
+		);
+		expect(marker.tier).toBe("podman");
+		expect(marker.posture).toBe("armed");
+	});
+
+	test("a zero/unspecified value maps to unknown, never armed or contained", () => {
+		// The generated default for an absent field is the 0 enum value; it must
+		// render as unknown so a user never reads an unresolved session as armed.
+		const marker = adaptRuntimeMarker(create(AgentSessionStatusSchema, {}));
+		expect(marker.tier).toBe("unknown");
+		expect(marker.posture).toBe("unknown");
+		expect(marker.posture).not.toBe("armed");
+		expect(marker.posture).not.toBe("unenforced");
+	});
+});
diff --git a/apps/ui/src/live/adapt.ts b/apps/ui/src/live/adapt.ts
index b83b92984..ad399c20e 100644
--- a/apps/ui/src/live/adapt.ts
+++ b/apps/ui/src/live/adapt.ts
@@ -21,10 +21,13 @@ import {
 	ChannelGroupVisibility,
 	ChannelKind,
 	ChannelPostPolicy,
+	EgressPosture,
 	ForgeProvider,
 	IssueState,
+	RuntimeTier,
 	type Account as WireAccount,
 	type AgentAttribution as WireAgentAttribution,
+	type AgentSessionStatus as WireAgentSessionStatus,
 	type Ask as WireAsk,
 	type AskQuestion as WireAskQuestion,
 	type ChangedStats as WireChangedStats,
@@ -73,6 +76,9 @@ import type {
 	Review as DomainReview,
 	ReviewThread as DomainReviewThread,
 	TrackerRef as DomainTrackerRef,
+	EgressPostureMark,
+	RuntimeMarker,
+	RuntimeTierMark,
 } from "../stub-data";
 import type { MapMessage } from "./comms-state";
 
@@ -556,3 +562,36 @@ export function adaptRosterEntry(
 		},
 	];
 }
+
+/** The wire `RuntimeTier` enum → the domain's runner-backend mark. Total over
+ *  the enum (`satisfies Record<RuntimeTier, …>` makes a new wire tier a compile
+ *  error here). `UNSPECIFIED → "unknown"`: an unresolved or version-skewed tier
+ *  is rendered honestly, never assumed to be a contained backend. */
+const RUNTIME_TIER: Record<RuntimeTier, RuntimeTierMark> = {
+	[RuntimeTier.UNSPECIFIED]: "unknown",
+	[RuntimeTier.PODMAN]: "podman",
+	[RuntimeTier.MICROVM]: "microvm",
+	[RuntimeTier.APPLE_CONTAINER]: "apple-container",
+	[RuntimeTier.HOST]: "host",
+} satisfies Record<RuntimeTier, RuntimeTierMark>;
+
+/** The wire `EgressPosture` enum → the domain's posture mark. Total, same
+ *  rationale as RUNTIME_TIER. `UNSPECIFIED → "unknown"`: an unresolved posture
+ *  is never rendered as contained. `UNENFORCED` is a DECLARED posture the user
+ *  must read as uncontained, not a failed arm (compass.proto EgressPosture). */
+const EGRESS_POSTURE: Record<EgressPosture, EgressPostureMark> = {
+	[EgressPosture.UNSPECIFIED]: "unknown",
+	[EgressPosture.ARMED]: "armed",
+	[EgressPosture.UNENFORCED]: "unenforced",
+} satisfies Record<EgressPosture, EgressPostureMark>;
+
+/** Map a wire `AgentSessionStatus` to the session runtime marker the roster
+ *  renders beside the state dot: the Runner-reported runtime tier and egress
+ *  posture, each mapped total over its wire enum. Pure — the identity/lifecycle
+ *  fields the status also carries are the presence path's job, not this marker's. */
+export function adaptRuntimeMarker(w: WireAgentSessionStatus): RuntimeMarker {
+	return {
+		tier: RUNTIME_TIER[w.runtimeTier],
+		posture: EGRESS_POSTURE[w.egressPosture],
+	};
+}
diff --git a/apps/ui/src/live/events.test.ts b/apps/ui/src/live/events.test.ts
index 54791d073..360b921a6 100644
--- a/apps/ui/src/live/events.test.ts
+++ b/apps/ui/src/live/events.test.ts
@@ -1,16 +1,19 @@
 import { describe, expect, test } from "bun:test";
 import {
+	AgentSessionStatusSchema,
 	CompassService,
 	create,
 	createCompassClient,
 	createRouterTransport,
+	EgressPosture,
 	IssueSchema,
 	IssueState,
+	RuntimeTier,
 	type SubscribeEventsResponse,
 	SubscribeEventsResponseSchema,
 	type Issue as WireIssue,
 } from "@compass/client";
-import type { Issue as DomainIssue } from "../stub-data";
+import type { Issue as DomainIssue, RuntimeMarker } from "../stub-data";
 import { runEventStream } from "./events";
 
 // The SubscribeEvents read-driver seam (RIG-1729 read slice). A fake server is a
@@ -111,7 +114,86 @@ async function drainUntil(predicate: () => boolean): Promise<void> {
 	}
 }
 
+// An agent-session-status response carrying the runtime tier + egress posture,
+// the payload the driver keys by account id into its runtime map.
+function statusResp(
+	seq: bigint,
+	account: string,
+	tier: RuntimeTier,
+	posture: EgressPosture,
+): SubscribeEventsResponse {
+	return create(SubscribeEventsResponseSchema, {
+		seq,
+		instanceEpoch: 7n,
+		payload: {
+			case: "agentSessionStatus",
+			value: create(AgentSessionStatusSchema, {
+				sessionId: `sess-${account}`,
+				agentAccountId: account,
+				runtimeTier: tier,
+				egressPosture: posture,
+			}),
+		},
+	});
+}
+
 describe("runEventStream (RIG-1729 read driver)", () => {
+	test("decodes a session status into a runtime marker keyed by account", async () => {
+		const transport = scriptedTransport([
+			statusResp(1n, "acc-host", RuntimeTier.HOST, EgressPosture.UNENFORCED),
+			statusResp(2n, "acc-pod", RuntimeTier.PODMAN, EgressPosture.ARMED),
+		]);
+		const client = createCompassClient(transport);
+		const abort = new AbortController();
+		let runtime: ReadonlyMap<string, RuntimeMarker> = new Map();
+		void runEventStream({
+			client,
+			onIssues: () => {},
+			onRuntime: (next) => {
+				runtime = next;
+			},
+			signal: abort.signal,
+		});
+
+		await drainUntil(() => runtime.size >= 2);
+		abort.abort();
+
+		expect(runtime.get("acc-host")).toEqual({
+			tier: "host",
+			posture: "unenforced",
+		});
+		expect(runtime.get("acc-pod")).toEqual({
+			tier: "podman",
+			posture: "armed",
+		});
+	});
+
+	test("skips a status whose account binding is unresolvable", async () => {
+		// An empty account id would key every unbound status under "", attaching
+		// one agent's posture to all of them.
+		const transport = scriptedTransport([
+			statusResp(1n, "", RuntimeTier.HOST, EgressPosture.UNENFORCED),
+			statusResp(2n, "acc-real", RuntimeTier.HOST, EgressPosture.UNENFORCED),
+		]);
+		const client = createCompassClient(transport);
+		const abort = new AbortController();
+		let runtime: ReadonlyMap<string, RuntimeMarker> = new Map();
+		void runEventStream({
+			client,
+			onIssues: () => {},
+			onRuntime: (next) => {
+				runtime = next;
+			},
+			signal: abort.signal,
+		});
+
+		await drainUntil(() => runtime.has("acc-real"));
+		abort.abort();
+
+		expect(runtime.size).toBe(1);
+		expect(runtime.has("")).toBe(false);
+	});
+
 	test("pushes adapted domain issues; a repeat id REPLACES (upsert)", async () => {
 		const transport = scriptedTransport([
 			issueResp(1n, "a", { title: "first", state: IssueState.TODO }),
diff --git a/apps/ui/src/live/events.ts b/apps/ui/src/live/events.ts
index d5235a647..795409532 100644
--- a/apps/ui/src/live/events.ts
+++ b/apps/ui/src/live/events.ts
@@ -41,8 +41,8 @@
 // (store.ts, behind options.compass).
 
 import type { CompassClient, SubscribeEventsResponse } from "@compass/client";
-import type { Issue as DomainIssue } from "../stub-data";
-import { adaptIssue } from "./adapt";
+import type { Issue as DomainIssue, RuntimeMarker } from "../stub-data";
+import { adaptIssue, adaptRuntimeMarker } from "./adapt";
 
 /** What the driver needs to run: the compass client, the sink for each new
  *  board snapshot, and the abort signal that cancels the whole run (component
@@ -53,6 +53,10 @@ export interface EventStreamOptions {
 	/** Called with the full current board (upsert-deduped by issue id) after each
 	 *  applied issue event. */
 	onIssues: (issues: DomainIssue[]) => void;
+	/** Called with each agent account's latest runtime marker, keyed by account
+	 *  id. A status whose account binding is no longer resolvable carries no
+	 *  account and is skipped rather than keyed under an empty id. */
+	onRuntime?: (runtime: ReadonlyMap<string, RuntimeMarker>) => void;
 	signal?: AbortSignal;
 	onError?: (error: unknown) => void;
 }
@@ -100,11 +104,15 @@ function abortableDelay(ms: number, signal?: AbortSignal): Promise<void> {
  *  start (re-read + re-tail). Each applied issue pushes the full board to
  *  `onIssues`. Resolves only when aborted. */
 export async function runEventStream(opts: EventStreamOptions): Promise<void> {
-	const { client, onIssues, signal, onError } = opts;
+	const { client, onIssues, onRuntime, signal, onError } = opts;
 	// The board, deduped by issue id: the durable ListBoardIssues re-snapshot
 	// plus live tail upserts both land here, so a re-sent id REPLACES rather
 	// than appends — this map IS the union.
 	const board = new Map<string, DomainIssue>();
+	// Each agent account's latest runtime marker, keyed by account id. Same
+	// upsert-by-key discipline as the board: a new status for an account
+	// replaces its marker.
+	const runtime = new Map<string, RuntimeMarker>();
 	// The single stream cursor (echoed as since_seq) and the server's instance
 	// epoch. Both 0 means a cold start → re-read + re-tail. Never persisted.
 	let sinceSeq = 0n;
@@ -123,6 +131,16 @@ export async function runEventStream(opts: EventStreamOptions): Promise<void> {
 	};
 
 	const applyPayload = (payload: SubscribeEventsPayload): void => {
+		if (payload.case === "agentSessionStatus") {
+			// No resolvable account binding means nothing to key the marker by;
+			// keying it under "" would attach one agent's posture to every
+			// unbound status.
+			const account = payload.value.agentAccountId;
+			if (account === "") return;
+			runtime.set(account, adaptRuntimeMarker(payload.value));
+			onRuntime?.(new Map(runtime));
+			return;
+		}
 		if (payload.case !== "issue") return;
 		const issue = adaptIssue(payload.value);
 		board.set(issue.id, issue);
@@ -169,8 +187,12 @@ export async function runEventStream(opts: EventStreamOptions): Promise<void> {
 					// The server can't serve our cursor gap-free. Clear the board +
 					// reset both cursors to a cold start and reconnect immediately for a
 					// fresh re-read + re-tail — a resync is a server directive, not a spin.
+					// The runtime markers clear with it: a stale posture surviving a
+					// resync could show a torn-down host session as still contained.
 					board.clear();
 					onIssues([]);
+					runtime.clear();
+					onRuntime?.(new Map());
 					sinceSeq = 0n;
 					instanceEpoch = 0n;
 					madeProgress = true;
diff --git a/apps/ui/src/roster.test.ts b/apps/ui/src/roster.test.ts
index 8a8a82a01..12835084c 100644
--- a/apps/ui/src/roster.test.ts
+++ b/apps/ui/src/roster.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import type { AgentPresenceInfo } from "./live/adapt";
 import { joinAgents } from "./roster";
-import type { Account } from "./stub-data";
+import type { Account, RuntimeMarker } from "./stub-data";
 
 // roster.ts is the pure join at the store's seam: it composes the board's live
 // `Agent` view-models from the durable `accounts` (identity) and the ephemeral
@@ -22,6 +22,36 @@ function userAccount(id: string): Account {
 }
 
 describe("joinAgents", () => {
+	test("joins a runtime marker onto its agent by account id", () => {
+		const accounts = [agentAccount("acc-host"), agentAccount("acc-pod")];
+		const presence = new Map<string, AgentPresenceInfo>([
+			["acc-host", { lifecycle: "working" }],
+			["acc-pod", { lifecycle: "working" }],
+		]);
+		const runtime = new Map<string, RuntimeMarker>([
+			["acc-host", { tier: "host", posture: "unenforced" }],
+			["acc-pod", { tier: "podman", posture: "armed" }],
+		]);
+
+		const agents = joinAgents(accounts, presence, runtime);
+
+		expect(agents[0]?.runtime).toEqual({ tier: "host", posture: "unenforced" });
+		expect(agents[1]?.runtime).toEqual({ tier: "podman", posture: "armed" });
+	});
+
+	test("leaves runtime undefined for an agent with no session status yet", () => {
+		const accounts = [agentAccount("acc-new")];
+		const presence = new Map<string, AgentPresenceInfo>([
+			["acc-new", { lifecycle: "working" }],
+		]);
+
+		const agents = joinAgents(accounts, presence, new Map());
+
+		// Undefined, never a default: guessing a posture would render an
+		// uncontained agent as contained.
+		expect(agents[0]?.runtime).toBeUndefined();
+	});
+
 	test("projects a present entry's lifecycle and activity onto the agent", () => {
 		const accounts = [agentAccount("acc-cook")];
 		const presence = new Map<string, AgentPresenceInfo>([
diff --git a/apps/ui/src/roster.ts b/apps/ui/src/roster.ts
index 729585620..577b00470 100644
--- a/apps/ui/src/roster.ts
+++ b/apps/ui/src/roster.ts
@@ -17,17 +17,24 @@
 // undefined → the defensive idle arm; only a genuine miss becomes "stopped".
 
 import type { AgentPresenceInfo } from "./live/adapt";
-import type { Account, Agent } from "./stub-data";
+import type { Account, Agent, RuntimeMarker } from "./stub-data";
 
 /** Join the durable agent accounts with their ephemeral presence into the
  *  board's `Agent` view-models. Filters to `kind === "agent"`, PRESERVES
  *  account order (the `agentTree` stable-order contract, stub-data.ts:372-377),
  *  and composes `{ account, lifecycle, activity, terminals: [] }` per agent. A
  *  presence-map MISS → `lifecycle: "stopped"` (R2 / DL-194); a present entry
- *  uses its `info.lifecycle` as-is (undefined stays undefined). */
+ *  uses its `info.lifecycle` as-is (undefined stays undefined).
+ *
+ *  `runtime` is a third independent source, keyed the same way: it arrives on
+ *  the session-status stream rather than the presence one, so an agent with no
+ *  session status yet carries no marker. A miss stays undefined — unlike
+ *  lifecycle there is no safe default, because guessing a posture would render
+ *  an uncontained agent as contained. */
 export function joinAgents(
 	accounts: readonly Account[],
 	presence: ReadonlyMap<string, AgentPresenceInfo>,
+	runtime: ReadonlyMap<string, RuntimeMarker> = new Map(),
 ): Agent[] {
 	const agents: Agent[] = [];
 	for (const account of accounts) {
@@ -37,6 +44,7 @@ export function joinAgents(
 			account,
 			lifecycle: info ? info.lifecycle : "stopped",
 			activity: info?.activity,
+			runtime: runtime.get(account.id),
 			terminals: [],
 		});
 	}
diff --git a/apps/ui/src/store.ts b/apps/ui/src/store.ts
index aac564bc9..1777c057e 100644
--- a/apps/ui/src/store.ts
+++ b/apps/ui/src/store.ts
@@ -59,6 +59,7 @@ import {
 	type Agent,
 	type DaemonInfo,
 	type Issue,
+	type RuntimeMarker,
 	STUB_AGENTS,
 	STUB_DAEMON,
 	STUB_ISSUES,
@@ -912,8 +913,15 @@ export function createAppStore(options: AppStoreOptions): AppStore {
 	// the join itself, gated on the live/offline switch: offline it is the
 	// fixture; live it re-joins only when accounts or presence change.
 	const presence = createMemo(() => comms().presence);
+	// Runtime markers arrive on the session-status stream, not the comms one, so
+	// they are their own signal joined in beside presence.
+	const [runtimeMarkers, setRuntimeMarkers] = createSignal<
+		ReadonlyMap<string, RuntimeMarker>
+	>(new Map());
 	const agents = createMemo<readonly Agent[]>(() =>
-		options.comms ? joinAgents(accounts(), presence()) : STUB_AGENTS,
+		options.comms
+			? joinAgents(accounts(), presence(), runtimeMarkers())
+			: STUB_AGENTS,
 	);
 	// Boot default (Record A §T5): the first hydrated pin that resolves to a
 	// visible agent, else the static `status` pane. Boot has no mid-view state to
@@ -1027,6 +1035,7 @@ export function createAppStore(options: AppStoreOptions): AppStore {
 		void runEventStream({
 			client,
 			onIssues: setIssues,
+			onRuntime: setRuntimeMarkers,
 			signal: eventsAbort.signal,
 			onError: (error) => options.onCommsError?.(error),
 		}).catch((error) => {
diff --git a/apps/ui/src/stub-data.ts b/apps/ui/src/stub-data.ts
index b1ef41fe7..4a70e951c 100644
--- a/apps/ui/src/stub-data.ts
+++ b/apps/ui/src/stub-data.ts
@@ -54,6 +54,30 @@ export type AgentState =
 	| "error"
 	| "disconnected";
 
+/** The runtime backend an agent session runs on — the marker beside the state
+ *  dot (Runner-reported, AgentSessionStatus.runtime_tier). `unknown` is an
+ *  unresolved/version-skewed tier, rendered honestly rather than assumed. */
+export type RuntimeTierMark =
+	| "podman"
+	| "microvm"
+	| "apple-container"
+	| "host"
+	| "unknown";
+
+/** How an agent session's egress is constrained (AgentSessionStatus.
+ *  egress_posture). `unenforced` is a DECLARED posture — the tier cannot
+ *  constrain egress at all (a host process shares the host network namespace),
+ *  so a user must read it as uncontained, never as a failed arm. `unknown` is
+ *  an unresolved posture, never rendered as contained. */
+export type EgressPostureMark = "armed" | "unenforced" | "unknown";
+
+/** The session runtime marker the roster renders beside the state dot: which
+ *  runner backend the session runs on and whether its egress is contained. */
+export interface RuntimeMarker {
+	readonly tier: RuntimeTierMark;
+	readonly posture: EgressPostureMark;
+}
+
 /** The kind of agent — the moat agents plus leveraged worker agents. */
 export type AgentRole = "supervisor" | "worker";
 
@@ -350,6 +374,11 @@ export interface Agent {
 	 *  process state. Absent/empty = none (the presence render shows the state
 	 *  dot + handle alone, as today). */
 	activity?: string;
+	/** The session runtime marker — which runner backend the current session
+	 *  runs on and whether its egress is contained (AgentSessionStatus, mapped by
+	 *  `adaptRuntimeMarker`). Absent when no session status has reached this
+	 *  client for the agent (the render shows the state dot alone). */
+	runtime?: RuntimeMarker;
 	/** UI-only roster config. Optional: a live agent has no fixture role. */
 	role?: AgentRole;
 	/** UI-only (the model the OMP SDK is set with). Optional for a live agent. */
diff --git a/packages/compass-client/src/index.ts b/packages/compass-client/src/index.ts
index 5c79abc01..ad5dad09c 100644
--- a/packages/compass-client/src/index.ts
+++ b/packages/compass-client/src/index.ts
@@ -504,12 +504,15 @@ export type {
 } from "./gen/compass/v1/compass_pb";
 export {
 	AgentSessionState,
+	AgentSessionStatusSchema,
 	CompassService,
+	EgressPosture,
 	ForgeProvider,
 	GetServerInfoResponseSchema,
 	IssueSchema,
 	IssueState,
 	PullRequestSchema,
+	RuntimeTier,
 	ServerState,
 	SubscribeEventsResponseSchema,
 } from "./gen/compass/v1/compass_pb";

From 9ba4c56332a1b637baa95d3b1d7ed45bde8756d4 Mon Sep 17 00:00:00 2001
From: mintaka <mintaka@rigel.build>
Date: Sat, 12 Sep 2026 12:56:51 -0400
Subject: [PATCH 2/2] fix(ui): fall back to unknown on a skewed runtime enum
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Review findings on the posture surfaces:

- `adaptRuntimeMarker` indexed the tier/posture maps bare. protobuf-es keeps
  an unknown numeric enum value on decode and the base tsconfig has `strict`
  without `noUncheckedIndexedAccess`, so a server newer than the UI yielded
  `undefined` — typed as present, and read as contained by `uncontained()`,
  silently dropping the warning it exists to show. Now falls back to
  `unknown`, matching the CLI's `!ok` arm.
- `joinAgents`' `runtime` parameter is required rather than defaulted, so
  rendering no markers is always a decision at the callsite.
- The tier mis-wiring guard covers the apple-container arm it omitted, and
  the completeness comment no longer claims a guarantee a hardcoded slice
  cannot give.

Co-authored-by: Matt Wilkinson <matt@rigel.build>
---
 apps/ui/src/live/adapt.test.ts   | 17 +++++++++++++++++
 apps/ui/src/live/adapt.ts        |  7 +++++--
 apps/ui/src/roster.test.ts       |  8 ++++----
 apps/ui/src/roster.ts            |  5 +++--
 go/internal/runtime/tier_test.go |  4 +++-
 5 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/apps/ui/src/live/adapt.test.ts b/apps/ui/src/live/adapt.test.ts
index 747604d18..191454880 100644
--- a/apps/ui/src/live/adapt.test.ts
+++ b/apps/ui/src/live/adapt.test.ts
@@ -1014,6 +1014,23 @@ describe("adaptRosterEntry", () => {
 });
 
 describe("adaptRuntimeMarker", () => {
+	test("maps an unknown wire value to unknown, not undefined", () => {
+		// A server newer than this UI can send an enum value it has no name for;
+		// an undefined posture reads as contained to every downstream check.
+		// The generated enum type is closed, but protobuf-es keeps an unnamed
+		// numeric value on decode, so the runtime shape is reproduced directly.
+		const skewed = create(AgentSessionStatusSchema, {
+			sessionId: "s-future",
+			agentAccountId: "acc-future",
+		});
+		Object.assign(skewed, { runtimeTier: 99, egressPosture: 99 });
+
+		const marker = adaptRuntimeMarker(skewed);
+
+		expect(marker.tier).toBe("unknown");
+		expect(marker.posture).toBe("unknown");
+	});
+
 	// The runtime marker maps AgentSessionStatus.{runtime_tier,egress_posture}
 	// to the user-facing roster tokens. The semantics a user reads: a host tier
 	// with unenforced egress is the host backend AND visibly uncontained; a
diff --git a/apps/ui/src/live/adapt.ts b/apps/ui/src/live/adapt.ts
index ad399c20e..373713016 100644
--- a/apps/ui/src/live/adapt.ts
+++ b/apps/ui/src/live/adapt.ts
@@ -590,8 +590,11 @@ const EGRESS_POSTURE: Record<EgressPosture, EgressPostureMark> = {
  *  posture, each mapped total over its wire enum. Pure — the identity/lifecycle
  *  fields the status also carries are the presence path's job, not this marker's. */
 export function adaptRuntimeMarker(w: WireAgentSessionStatus): RuntimeMarker {
+	// protobuf-es keeps an unknown numeric enum value on decode, so a server
+	// newer than this UI yields a miss here. Fall back rather than index bare:
+	// an undefined posture would silently drop the uncontained warning.
 	return {
-		tier: RUNTIME_TIER[w.runtimeTier],
-		posture: EGRESS_POSTURE[w.egressPosture],
+		tier: RUNTIME_TIER[w.runtimeTier] ?? "unknown",
+		posture: EGRESS_POSTURE[w.egressPosture] ?? "unknown",
 	};
 }
diff --git a/apps/ui/src/roster.test.ts b/apps/ui/src/roster.test.ts
index 12835084c..0643efe92 100644
--- a/apps/ui/src/roster.test.ts
+++ b/apps/ui/src/roster.test.ts
@@ -58,7 +58,7 @@ describe("joinAgents", () => {
 			["acc-cook", { lifecycle: "working", activity: "cooking" }],
 		]);
 
-		const agents = joinAgents(accounts, presence);
+		const agents = joinAgents(accounts, presence, new Map());
 
 		expect(agents).toHaveLength(1);
 		expect(agents[0]?.account.id).toBe("acc-cook");
@@ -72,7 +72,7 @@ describe("joinAgents", () => {
 		// An account present in `accounts` but absent from the presence seed — a
 		// snapshot-boundary race or an un-re-seeded accountChanged arrival — is an
 		// at-rest/unstarted agent: the stopped dot, never the false-live idle dot.
-		const agents = joinAgents([agentAccount("acc-new")], new Map());
+		const agents = joinAgents([agentAccount("acc-new")], new Map(), new Map());
 
 		expect(agents[0]?.lifecycle).toBe("stopped");
 		// The two failure modes the rule exists to forbid.
@@ -91,7 +91,7 @@ describe("joinAgents", () => {
 			["acc-quiet", { lifecycle: undefined, activity: undefined }],
 		]);
 
-		const agents = joinAgents([agentAccount("acc-quiet")], presence);
+		const agents = joinAgents([agentAccount("acc-quiet")], presence, new Map());
 
 		expect(agents[0]?.lifecycle).toBeUndefined();
 		expect(agents[0]?.lifecycle).not.toBe("stopped");
@@ -111,7 +111,7 @@ describe("joinAgents", () => {
 			["acc-alpha", { lifecycle: "idle" }],
 		]);
 
-		const agents = joinAgents(accounts, presence);
+		const agents = joinAgents(accounts, presence, new Map());
 
 		// Only the three agent accounts, in their original input order.
 		expect(agents.map((a) => a.account.id)).toEqual([
diff --git a/apps/ui/src/roster.ts b/apps/ui/src/roster.ts
index 577b00470..e5884b3b4 100644
--- a/apps/ui/src/roster.ts
+++ b/apps/ui/src/roster.ts
@@ -30,11 +30,12 @@ import type { Account, Agent, RuntimeMarker } from "./stub-data";
  *  the session-status stream rather than the presence one, so an agent with no
  *  session status yet carries no marker. A miss stays undefined — unlike
  *  lifecycle there is no safe default, because guessing a posture would render
- *  an uncontained agent as contained. */
+ *  an uncontained agent as contained. It is required rather than defaulted so
+ *  rendering no markers is always a decision at the callsite. */
 export function joinAgents(
 	accounts: readonly Account[],
 	presence: ReadonlyMap<string, AgentPresenceInfo>,
-	runtime: ReadonlyMap<string, RuntimeMarker> = new Map(),
+	runtime: ReadonlyMap<string, RuntimeMarker>,
 ): Agent[] {
 	const agents: Agent[] = [];
 	for (const account of accounts) {
diff --git a/go/internal/runtime/tier_test.go b/go/internal/runtime/tier_test.go
index 1d0b789a3..b1018aaf8 100644
--- a/go/internal/runtime/tier_test.go
+++ b/go/internal/runtime/tier_test.go
@@ -4,7 +4,8 @@ import "testing"
 
 // TestEveryBackendNamesItsOwnTier: the tier is reported on a security surface,
 // so each production backend must name itself rather than fall through to the
-// empty tier. A backend added without a Tier method would fail here.
+// empty tier. This catches a regression on a listed backend; a NEW backend is
+// only covered once it is added here and to the SelectBackend cases below.
 func TestEveryBackendNamesItsOwnTier(t *testing.T) {
 	for _, tc := range []struct {
 		name   string
@@ -43,6 +44,7 @@ func TestSelectBackendTierMatchesTheRequestedBackend(t *testing.T) {
 		{"", WorkloadTierPodman},
 		{"podman", WorkloadTierPodman},
 		{"microvm", WorkloadTierMicroVM},
+		{"apple-container", WorkloadTierAppleContainer},
 		{"host", WorkloadTierHost},
 	} {
 		engine, err := SelectBackend(BackendConfig{Backend: tc.backend})