@mattstack/rt-client 0.4.1 → 0.6.0

package/dist/settings/identity.d.ts

@@ -25,26 +25,9 @@
  *    through `identityFromRemote`, memoized per path so repeated callers in
  *    one process don't re-spawn git.
  */
-export type RepoIdentity = {
-    kind: "remote";
-    id: string;
-} | {
-    kind: "path";
-    id: string;
-};
-/**
- * The wire form crosses the daemon socket, sits in board config, and lands in
- * console's `/runs/:repo/...` URL — all of which need one slash-free segment.
- * `encodeURIComponent` guarantees that and is exactly reversible.
- */
-export declare function serializeIdentity(id: RepoIdentity): string;
-export declare function parseIdentity(wire: string): RepoIdentity | null;
-/**
- * Pure normalization: `remote` → `host/path` (lowercase host, `.git` and
- * embedded credentials stripped) or null when the remote doesn't match a
- * recognized host form (local paths, garbage input).
- */
-export declare function normalizeRemote(remote: string): string | null;
+import { type RepoIdentity } from "./identity-codec.ts";
+export { serializeIdentity, parseIdentity, normalizeRemote } from "./identity-codec.ts";
+export type { RepoIdentity } from "./identity-codec.ts";
 /**
  * The sync helper every non-derivation call site uses: machine-store
  * fork/multi-remote overrides (exact remote-URL match) then normalizeRemote.

package/dist/transport.d.ts

@@ -6,6 +6,15 @@ export interface RtResponse<T = unknown> {
 export interface RtClientOptions {
     sockPath?: string;
     wsUrl?: string;
+    /** Per-call override of rtCommand's own default (15s); chat's pulse wrapper needs an 800ms hook budget. */
+    timeoutMs?: number;
+    /**
+     * Test seam for createRelay (relay.ts): swaps the daemon subscription for
+     * a fake without a live WebSocket server. Typed structurally against
+     * relay.ts's `subscribe` rather than importing its RelayEventType, which
+     * would make this module depend on the one that already depends on it.
+     */
+    subscribeImpl?: (onEvent: (type: string, data: unknown) => void, opts?: RtClientOptions) => () => void;
 }
 /**
  * Display-only: a module-load snapshot for callers that just want to show

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mattstack/rt-client",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "type": "module",
   "exports": {
     ".": {
@@ -9,6 +9,12 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./identity": {
+      "types": "./dist/settings/identity-codec.d.ts",
+      "bun": "./src/settings/identity-codec.ts",
+      "import": "./dist/settings/identity-codec.js",
+      "default": "./dist/settings/identity-codec.js"
+    },
     "./test/fake-daemon.ts": "./test/fake-daemon.ts"
   },
   "peerDependencies": {
@@ -39,7 +45,7 @@
     "bun": ">=1.0.0"
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --packages external && tsc -p tsconfig.json",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm --packages external && bun build src/settings/identity-codec.ts --outfile dist/settings/identity-codec.js --target browser --format esm && tsc -p tsconfig.json",
     "check-types": "tsc --noEmit -p tsconfig.json",
     "prepack": "bun run build"
   },

package/src/client.ts

@@ -10,6 +10,7 @@ import type {
   ProjectMRsData,
   DiscussionsData,
   MrByBranchData,
+  BranchEnrichment,
   ForgeSlug,
   ForgeTokenData,
   RunSummary,
@@ -18,6 +19,8 @@ import type {
   ChatMember,
   ChatMessage,
   RoomSummary,
+  BuddyStatus,
+  PresenceRow,
 } from "./commands.ts";
 
 /**
@@ -66,6 +69,22 @@ export function readMrsByBranch(
   );
 }
 
+/**
+ * Cached ticket/MR enrichment for a set of branches, keyed by branch name
+ * (the cache's own primary key -- see lib/state/branch-cache.ts). Serves
+ * whatever the daemon already has; it does not trigger a fetch.
+ */
+export function readBranchCache(
+  branches: string[],
+  opts: RtClientOptions = {},
+): Promise<RtResponse<Record<string, BranchEnrichment>>> {
+  return rtCommand<Record<string, BranchEnrichment>>(
+    "cache:read",
+    { branches },
+    { sockPath: opts.sockPath, timeoutMs: 10_000 },
+  );
+}
+
 /**
  * The forge token for one tracked repo (MAT-33). Grant-gated on the daemon
  * side: an untracked repo comes back `ok: false` with the `rt daemon track`
@@ -134,21 +153,23 @@ export function chatJoin(
   if (a.wakeOn !== undefined) payload.wakeOn = a.wakeOn;
   if (a.cwd !== undefined) payload.cwd = a.cwd;
   if (a.pane !== undefined) payload.pane = a.pane;
-  return rtCommand<{ handle: string; memberCount: number; unread: number }>("chat:join", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ handle: string; memberCount: number; unread: number }>("chat:join", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatLeave(
   a: { room: string; handle: string },
   o: RtClientOptions = {},
 ): Promise<RtResponse<Record<string, never>>> {
-  return rtCommand<Record<string, never>>("chat:leave", { room: a.room, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<Record<string, never>>("chat:leave", { room: a.room, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatPost(
-  a: { room: string; handle: string; body: string },
+  a: { room: string; handle: string; body: string; mentions?: string[] },
   o: RtClientOptions = {},
 ): Promise<RtResponse<{ id: number; recipients: string[] }>> {
-  return rtCommand<{ id: number; recipients: string[] }>("chat:post", { room: a.room, handle: a.handle, body: a.body }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  const payload: Record<string, unknown> = { room: a.room, handle: a.handle, body: a.body };
+  if (a.mentions !== undefined) payload.mentions = a.mentions;
+  return rtCommand<{ id: number; recipients: string[] }>("chat:post", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatRead(
@@ -159,21 +180,21 @@ export function chatRead(
   if (a.room !== undefined) payload.room = a.room;
   if (a.limit !== undefined) payload.limit = a.limit;
   if (a.sinceMs !== undefined) payload.sinceMs = a.sinceMs;
-  return rtCommand<{ rooms: { room: string; messages: ChatMessage[] }[] }>("chat:read", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ rooms: { room: string; messages: ChatMessage[] }[] }>("chat:read", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatRooms(
   a: { handle: string },
   o: RtClientOptions = {},
 ): Promise<RtResponse<{ rooms: RoomSummary[] }>> {
-  return rtCommand<{ rooms: RoomSummary[] }>("chat:rooms", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ rooms: RoomSummary[] }>("chat:rooms", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatWho(
   a: { room: string },
   o: RtClientOptions = {},
 ): Promise<RtResponse<{ members: ChatMember[] }>> {
-  return rtCommand<{ members: ChatMember[] }>("chat:who", { room: a.room }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ members: ChatMember[] }>("chat:who", { room: a.room }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatMark(
@@ -182,7 +203,7 @@ export function chatMark(
 ): Promise<RtResponse<Record<string, never>>> {
   const payload: Record<string, unknown> = { handle: a.handle };
   if (a.room !== undefined) payload.room = a.room;
-  return rtCommand<Record<string, never>>("chat:mark", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<Record<string, never>>("chat:mark", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatMessages(
@@ -192,30 +213,35 @@ export function chatMessages(
   const payload: Record<string, unknown> = { room: a.room };
   if (a.before !== undefined) payload.before = a.before;
   if (a.limit !== undefined) payload.limit = a.limit;
-  return rtCommand<{ messages: ChatMessage[] }>("chat:messages", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ messages: ChatMessage[] }>("chat:messages", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatArm(
-  a: { handle: string; room?: string },
+  a: { handle: string; room?: string; sessionId?: string },
   o: RtClientOptions = {},
 ): Promise<RtResponse<Record<string, never>>> {
   const payload: Record<string, unknown> = { handle: a.handle };
   if (a.room !== undefined) payload.room = a.room;
-  return rtCommand<Record<string, never>>("chat:arm", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  if (a.sessionId !== undefined) payload.sessionId = a.sessionId;
+  return rtCommand<Record<string, never>>("chat:arm", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatTouch(
-  a: { handle: string },
+  a: { handle: string; sessionId?: string },
   o: RtClientOptions = {},
 ): Promise<RtResponse<Record<string, never>>> {
-  return rtCommand<Record<string, never>>("chat:touch", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  const payload: Record<string, unknown> = { handle: a.handle };
+  if (a.sessionId !== undefined) payload.sessionId = a.sessionId;
+  return rtCommand<Record<string, never>>("chat:touch", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatDisarm(
-  a: { handle: string },
+  a: { handle: string; sessionId?: string },
   o: RtClientOptions = {},
 ): Promise<RtResponse<Record<string, never>>> {
-  return rtCommand<Record<string, never>>("chat:disarm", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  const payload: Record<string, unknown> = { handle: a.handle };
+  if (a.sessionId !== undefined) payload.sessionId = a.sessionId;
+  return rtCommand<Record<string, never>>("chat:disarm", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function chatUnreadWaking(
@@ -224,9 +250,76 @@ export function chatUnreadWaking(
 ): Promise<RtResponse<{ rooms: { room: string; count: number; mentions: number; maxId: number }[] }>> {
   const payload: Record<string, unknown> = { handle: a.handle };
   if (a.room !== undefined) payload.room = a.room;
-  return rtCommand<{ rooms: { room: string; count: number; mentions: number; maxId: number }[] }>("chat:unread-waking", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ rooms: { room: string; count: number; mentions: number; maxId: number }[] }>("chat:unread-waking", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+// ─── Presence ──────────────────────────────────────────────────────────
+
+export function chatSignIn(
+  a: { sessionId: string; baseHandle: string; cwd?: string; repo?: string; branch?: string; pane?: string; statusText?: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ handle: string; reclaimed: boolean }>> {
+  const payload: Record<string, unknown> = { sessionId: a.sessionId, baseHandle: a.baseHandle };
+  if (a.cwd !== undefined) payload.cwd = a.cwd;
+  if (a.repo !== undefined) payload.repo = a.repo;
+  if (a.branch !== undefined) payload.branch = a.branch;
+  if (a.pane !== undefined) payload.pane = a.pane;
+  if (a.statusText !== undefined) payload.statusText = a.statusText;
+  return rtCommand<{ handle: string; reclaimed: boolean }>("chat:sign-in", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatSignOut(
+  a: { sessionId: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<Record<string, never>>> {
+  return rtCommand<Record<string, never>>("chat:sign-out", { sessionId: a.sessionId }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatAway(
+  a: { sessionId: string; text: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<Record<string, never>>> {
+  return rtCommand<Record<string, never>>("chat:away", { sessionId: a.sessionId, text: a.text }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatBack(
+  a: { sessionId: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<Record<string, never>>> {
+  return rtCommand<Record<string, never>>("chat:back", { sessionId: a.sessionId }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatBuddies(
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ buddies: Array<PresenceRow & { status: BuddyStatus }> }>> {
+  return rtCommand<{ buddies: Array<PresenceRow & { status: BuddyStatus }> }>("chat:buddies", {}, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
+}
+
+export function chatPulse(
+  a: { sessionId: string; cwd?: string; repo?: string; branch?: string; pane?: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ unread: { dms: number; mentions: number; rooms: number }; status: BuddyStatus }>> {
+  const payload: Record<string, unknown> = { sessionId: a.sessionId };
+  if (a.cwd !== undefined) payload.cwd = a.cwd;
+  if (a.repo !== undefined) payload.repo = a.repo;
+  if (a.branch !== undefined) payload.branch = a.branch;
+  if (a.pane !== undefined) payload.pane = a.pane;
+  return rtCommand<{ unread: { dms: number; mentions: number; rooms: number }; status: BuddyStatus }>(
+    "chat:pulse",
+    payload,
+    { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 },
+  );
+}
+
+export function chatDm(
+  a: { from: string; to: string; body: string; sessionId?: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ room: string; id: number; recipients: string[] }>> {
+  const payload: Record<string, unknown> = { from: a.from, to: a.to, body: a.body };
+  if (a.sessionId !== undefined) payload.sessionId = a.sessionId;
+  return rtCommand<{ room: string; id: number; recipients: string[] }>("chat:dm", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }
 
 export function eventsHead(o: RtClientOptions = {}): Promise<RtResponse<{ cursor: number }>> {
-  return rtCommand<{ cursor: number }>("events:head", {}, { sockPath: o.sockPath, timeoutMs: 10_000 });
+  return rtCommand<{ cursor: number }>("events:head", {}, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 10_000 });
 }

package/src/commands.ts

@@ -45,6 +45,21 @@ export interface MrByBranchData {
   syncedAt: number;
 }
 
+/**
+ * Trimmed, structural view of the daemon's `CacheEntry` (lib/state/branch-cache.ts) --
+ * rt-client cannot import daemon/lib internals, so this names only the fields
+ * console's run-view rows read, spelled exactly as they land on the wire
+ * (`mr` is `toMRInfo(pr)`, i.e. `getMRDashboardProps` -- camelCase `webUrl`,
+ * nested `pipeline.status`, no `ciStatus`). Extra wire fields (including the
+ * rest of `pipeline`) are fine; anything this shape doesn't name is simply
+ * not surfaced.
+ */
+export interface BranchEnrichment {
+  ticket: { identifier: string; title: string; url: string } | null;
+  mr: { iid: number; webUrl: string | null; state: string; pipeline: { status: string } | null } | null;
+  fetchedAt: number;
+}
+
 /** Forges the daemon can hold a token for. */
 export type ForgeSlug = "gitlab" | "github";
 
@@ -75,6 +90,8 @@ export interface ChatMember {
   armedAt?: number;
   cwd?: string;
   pane?: string;
+  /** Presence-joined by chat:who's handler — the only place this type is ever returned, and it always attaches one. */
+  status: BuddyStatus;
 }
 
 export interface ChatMessage {
@@ -93,13 +110,41 @@ export interface RoomSummary {
   unread: number;
   mentions: number;
   lastPostedAt?: number;
+  /** Set only by chat:rooms's left join against chat_dms. */
+  kind?: "dm";
+  participants?: { a: string; b: string };
+  /** Set only by chat:rooms's left join against chat_room_defaults; undefined for a room never stamped a default (every DM room included). */
+  defaultWake?: WakeMode;
+}
+
+/**
+ * Duplicated shape on purpose, same reasoning as ChatMember/ChatMessage
+ * above: mirrors lib/state/presence-store.ts's types, which rt-client
+ * cannot import.
+ */
+export type BuddyStatus = "live" | "idle" | "deaf" | "offline";
+
+export interface PresenceRow {
+  sessionId: string;
+  handle: string;
+  baseHandle: string;
+  cwd?: string;
+  repo?: string;
+  branch?: string;
+  pane?: string;
+  statusText?: string;
+  signedInAt: number;
+  lastSeenAt: number;
+  tailSeenAt?: number;
+  armedAt?: number;
+  signedOutAt?: number;
 }
 
 // SKILLS-53: one judgment, computed once in rt, so the console and the tray
 // never derive two verdicts that can disagree.
 export type Attention = {
   needs: boolean;
-  reason: "failed" | "stale" | "stranded" | null;
+  reason: "failed" | "stale" | "stranded" | "blocked" | null;
   evidence: string;
 };
 
@@ -120,6 +165,17 @@ export interface RunSummary {
       the run has not produced that field yet. */
   ticket: string | null;
   branch: string | null;
+  /** The herdr agent attributed to this run (matched by recorded claude
+      session, else by worktree), mirrored live from `herdr agent list`.
+      Null when no agent matches or herdr is unavailable; absent on
+      pre-mirror daemons. */
+  agent?: RunAgent | null;
+  /** Executed stages only, in run order — the pipeline may define more that have not started. */
+  stages?: { name: string; status: string; started_at: number | null }[];
+}
+export interface RunAgent {
+  status: "working" | "idle" | "blocked" | "done" | "unknown";
+  pane: string;
 }
 export interface RunStageRow {
   name: string; status: string; attempt: number;
@@ -188,16 +244,33 @@ export interface Commands {
   "runs:abandon": { payload: { runId: string; repo?: string; reason?: string }; data: { ok: boolean } };
   "chat:join": { payload: { room: string; handle: string; wakeOn?: WakeMode; cwd?: string; pane?: string }; data: { handle: string; memberCount: number; unread: number } };
   "chat:leave": { payload: { room: string; handle: string }; data: Record<string, never> };
-  "chat:post": { payload: { room: string; handle: string; body: string }; data: { id: number; recipients: string[] } };
+  "chat:post": { payload: { room: string; handle: string; body: string; mentions?: string[] }; data: { id: number; recipients: string[] } };
   "chat:read": { payload: { handle: string; room?: string; limit?: number; sinceMs?: number }; data: { rooms: { room: string; messages: ChatMessage[] }[] } };
   "chat:rooms": { payload: { handle: string }; data: { rooms: RoomSummary[] } };
   "chat:who": { payload: { room: string }; data: { members: ChatMember[] } };
   "chat:mark": { payload: { handle: string; room?: string }; data: Record<string, never> };
   "chat:messages": { payload: { room: string; before?: number; limit?: number }; data: { messages: ChatMessage[] } };
-  "chat:arm": { payload: { handle: string; room?: string }; data: Record<string, never> };
-  "chat:touch": { payload: { handle: string }; data: Record<string, never> };
-  "chat:disarm": { payload: { handle: string }; data: Record<string, never> };
+  "chat:arm": { payload: { handle: string; room?: string; sessionId?: string }; data: Record<string, never> };
+  "chat:touch": { payload: { handle: string; sessionId?: string }; data: Record<string, never> };
+  "chat:disarm": { payload: { handle: string; sessionId?: string }; data: Record<string, never> };
   "chat:unread-waking": { payload: { handle: string; room?: string }; data: { rooms: { room: string; count: number; mentions: number; maxId: number }[] } };
+
+  // A session id keys these to one signed-in handle, not a room-membership
+  // handle string.
+  "chat:sign-in": {
+    payload: { sessionId: string; baseHandle: string; cwd?: string; repo?: string; branch?: string; pane?: string; statusText?: string };
+    data: { handle: string; reclaimed: boolean };
+  };
+  "chat:sign-out": { payload: { sessionId: string }; data: Record<string, never> };
+  "chat:away": { payload: { sessionId: string; text: string }; data: Record<string, never> };
+  "chat:back": { payload: { sessionId: string }; data: Record<string, never> };
+  "chat:buddies": { payload: Record<string, never>; data: { buddies: Array<PresenceRow & { status: BuddyStatus }> } };
+  /** `unread`'s three fields are disjoint and sum to the true total: `dms` is DM-room waking count; `mentions` is non-DM waking mentions; `rooms` is non-DM waking count minus those mentions (never negative). */
+  "chat:pulse": {
+    payload: { sessionId: string; cwd?: string; repo?: string; branch?: string; pane?: string };
+    data: { unread: { dms: number; mentions: number; rooms: number }; status: BuddyStatus };
+  };
+  "chat:dm": { payload: { from: string; to: string; body: string; sessionId?: string }; data: { room: string; id: number; recipients: string[] } };
 }
 
 export type CommandName = keyof Commands;
@@ -227,4 +300,11 @@ export const COMMAND_NAMES: readonly CommandName[] = [
   "chat:touch",
   "chat:disarm",
   "chat:unread-waking",
+  "chat:sign-in",
+  "chat:sign-out",
+  "chat:away",
+  "chat:back",
+  "chat:buddies",
+  "chat:pulse",
+  "chat:dm",
 ];

package/src/health.ts

@@ -0,0 +1,15 @@
+import { eventsHead } from "./client.ts";
+import type { RtClientOptions } from "./transport.ts";
+
+/**
+ * A daemon-down result is a successful probe, not a failure of this call —
+ * eventsHead already never throws (transport.ts degrades every fetch to
+ * `{ ok: false, error }`), so this only reshapes that envelope for callers
+ * who want a boolean, not `{ ok, data, error }`.
+ */
+export async function daemonHealth(
+  opts: RtClientOptions = {},
+): Promise<{ reachable: boolean; error?: string }> {
+  const res = await eventsHead(opts);
+  return { reachable: res.ok, error: res.ok ? undefined : res.error };
+}

package/src/index.ts

@@ -5,6 +5,7 @@ export {
   readProjectMRs,
   readDiscussions,
   readMrsByBranch,
+  readBranchCache,
   resolveForgeToken,
   listRuns,
   getRun,
@@ -21,6 +22,13 @@ export {
   chatTouch,
   chatDisarm,
   chatUnreadWaking,
+  chatSignIn,
+  chatSignOut,
+  chatAway,
+  chatBack,
+  chatBuddies,
+  chatPulse,
+  chatDm,
   eventsHead,
 } from "./client.ts";
 
@@ -33,6 +41,7 @@ export type {
   DiscussionsData,
   MrByBranchEntry,
   MrByBranchData,
+  BranchEnrichment,
   Commands,
   CommandName,
   ForgeSlug,
@@ -47,11 +56,15 @@ export type {
   ChatMember,
   ChatMessage,
   RoomSummary,
+  BuddyStatus,
+  PresenceRow,
 } from "./commands.ts";
 
-export { subscribe, DEFAULT_WS_URL } from "./relay.ts";
+export { subscribe, createRelay, DEFAULT_WS_URL } from "./relay.ts";
 export type { RelayEventType } from "./relay.ts";
 
+export { daemonHealth } from "./health.ts";
+
 export { repoNameForPath } from "./repos.ts";
 
 // ─── Settings (RT-50) ────────────────────────────────────────────────────────

package/src/relay.ts

@@ -59,3 +59,34 @@ export function subscribe(
     try { ws?.close(); } catch { /* already closed */ }
   };
 }
+
+/**
+ * One daemon subscription for the whole process, republished onto a
+ * caller-chosen pub/sub topic. Every subscriber to that topic then shares
+ * one relay connection instead of each opening its own — filtering here
+ * (rather than at each subscriber) is what keeps an unrelated event from
+ * making every subscriber re-render.
+ *
+ * Ported from console's `startRelay` (src/server/ws.ts) with the match
+ * predicate and target topic lifted to arguments.
+ */
+export function createRelay(
+  cfg: { match: (topic: string) => boolean; topic: string; publish: (topic: string, data: string) => void },
+  opts: RtClientOptions = {},
+): () => void {
+  const doSubscribe = opts.subscribeImpl ?? subscribe;
+  return doSubscribe((type, data) => {
+    if (type !== "event") return;
+    const frame = data as { topic?: unknown };
+    if (typeof frame?.topic !== "string" || !cfg.match(frame.topic)) return;
+    // Serializing outside the catch keeps the suppression narrow: only a
+    // publish that rejects its own frame is expected here, and one
+    // subscriber's broken publish must not tear down the shared relay.
+    const payload = JSON.stringify(data);
+    try {
+      cfg.publish(cfg.topic, payload);
+    } catch {
+      /* the subscriber went away */
+    }
+  }, opts);
+}

package/src/settings/identity-codec.ts

@@ -0,0 +1,82 @@
+/**
+ * The pure half of the repo-identity contract: the wire codec and the
+ * remote-URL normalizer. Split from identity.ts so browser bundles can key
+ * and label repos without dragging in fs/child_process — this module must
+ * never import node builtins or anything that does (the `./identity`
+ * subpath export points here, and a browser consumer evaluates it at module
+ * scope). Override-aware and derivation entry points stay in identity.ts.
+ */
+
+// Full-URL forms: scheme://[user[:pass]@]host/path — https, ssh, git, http, ...
+const URL_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^@/]+@)?([^/]+)\/(.+)$/;
+
+// scp-like scp syntax: [user@]host:path (git@gitlab.com:group/repo.git).
+// Deliberately excludes anything starting with "/" (absolute local paths)
+// so a Windows-drive-letter-free local remote never falsely matches.
+const SCP_RE = /^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/;
+
+export type RepoIdentity =
+  | { kind: "remote"; id: string }
+  | { kind: "path"; id: string };
+
+/**
+ * The wire form crosses the daemon socket, sits in board config, and lands in
+ * console's `/runs/:repo/...` URL — all of which need one slash-free segment.
+ * `encodeURIComponent` guarantees that and is exactly reversible.
+ */
+export function serializeIdentity(id: RepoIdentity): string {
+  return `${id.kind}:${encodeURIComponent(id.id)}`;
+}
+
+export function parseIdentity(wire: string): RepoIdentity | null {
+  const colon = wire.indexOf(":");
+  if (colon === -1) return null;
+  const kind = wire.slice(0, colon);
+  if (kind !== "remote" && kind !== "path") return null;
+  const encoded = wire.slice(colon + 1);
+  let id: string;
+  try {
+    id = decodeURIComponent(encoded);
+  } catch {
+    return null;
+  }
+  // Canonical wires only: the id segment must be byte-for-byte what
+  // serializeIdentity emits. Guard sites validate with parseIdentity and then
+  // use the WIRE as a single path component (repoDataDir et al.) — a
+  // hand-built wire with a literal "/" ("path:../..") would otherwise parse
+  // and escape the state directory.
+  if (encodeURIComponent(id) !== encoded) return null;
+  return { kind, id };
+}
+
+/**
+ * Pure normalization: `remote` → `host/path` (lowercase host, `.git` and
+ * embedded credentials stripped) or null when the remote doesn't match a
+ * recognized host form (local paths, garbage input).
+ */
+export function normalizeRemote(remote: string): string | null {
+  const trimmed = remote.trim();
+  if (!trimmed) return null;
+
+  let host: string | undefined;
+  let path: string | undefined;
+
+  const urlMatch = URL_RE.exec(trimmed);
+  if (urlMatch) {
+    host = urlMatch[1];
+    path = urlMatch[2];
+  } else if (!trimmed.startsWith("/") && !trimmed.startsWith("~")) {
+    const scpMatch = SCP_RE.exec(trimmed);
+    if (scpMatch) {
+      host = scpMatch[1];
+      path = scpMatch[2];
+    }
+  }
+
+  if (!host || !path) return null;
+
+  const normalizedPath = path.replace(/\.git$/, "").replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalizedPath) return null;
+
+  return `${host.toLowerCase()}/${normalizedPath}`;
+}