@mattstack/rt-client 0.4.1 → 0.6.0

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import type { RtResponse, RtClientOptions } from "./transport.ts";
-import type { DemandDecl, ProjectMRsData, DiscussionsData, MrByBranchData, ForgeSlug, ForgeTokenData, RunSummary, RunDetail, WakeMode, ChatMember, ChatMessage, RoomSummary } from "./commands.ts";
+import type { DemandDecl, ProjectMRsData, DiscussionsData, MrByBranchData, BranchEnrichment, ForgeSlug, ForgeTokenData, RunSummary, RunDetail, WakeMode, ChatMember, ChatMessage, RoomSummary, BuddyStatus, PresenceRow } from "./commands.ts";
 /**
  * One repo's project open-MR store. A cold repo forces a full paginated sync
  * on the daemon side when maxAgeMs demands it, which can run tens of seconds
@@ -13,6 +13,12 @@ import type { DemandDecl, ProjectMRsData, DiscussionsData, MrByBranchData, Forge
 export declare function readProjectMRs(repoName: string, maxAgeMs?: number, opts?: RtClientOptions, demand?: DemandDecl): Promise<RtResponse<ProjectMRsData>>;
 export declare function readDiscussions(repoName: string, iid: number, opts?: RtClientOptions): Promise<RtResponse<DiscussionsData>>;
 export declare function readMrsByBranch(repoName: string, branches: string[], opts?: RtClientOptions): Promise<RtResponse<MrByBranchData>>;
+/**
+ * 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 declare function readBranchCache(branches: string[], opts?: RtClientOptions): Promise<RtResponse<Record<string, BranchEnrichment>>>;
 /**
  * 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`
@@ -52,6 +58,7 @@ export declare function chatPost(a: {
     room: string;
     handle: string;
     body: string;
+    mentions?: string[];
 }, o?: RtClientOptions): Promise<RtResponse<{
     id: number;
     recipients: string[];
@@ -91,12 +98,15 @@ export declare function chatMessages(a: {
 export declare function chatArm(a: {
     handle: string;
     room?: string;
+    sessionId?: string;
 }, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
 export declare function chatTouch(a: {
     handle: string;
+    sessionId?: string;
 }, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
 export declare function chatDisarm(a: {
     handle: string;
+    sessionId?: string;
 }, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
 export declare function chatUnreadWaking(a: {
     handle: string;
@@ -109,6 +119,57 @@ export declare function chatUnreadWaking(a: {
         maxId: number;
     }[];
 }>>;
+export declare 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;
+}>>;
+export declare function chatSignOut(a: {
+    sessionId: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatAway(a: {
+    sessionId: string;
+    text: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatBack(a: {
+    sessionId: string;
+}, o?: RtClientOptions): Promise<RtResponse<Record<string, never>>>;
+export declare function chatBuddies(o?: RtClientOptions): Promise<RtResponse<{
+    buddies: Array<PresenceRow & {
+        status: BuddyStatus;
+    }>;
+}>>;
+export declare 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;
+}>>;
+export declare function chatDm(a: {
+    from: string;
+    to: string;
+    body: string;
+    sessionId?: string;
+}, o?: RtClientOptions): Promise<RtResponse<{
+    room: string;
+    id: number;
+    recipients: string[];
+}>>;
 export declare function eventsHead(o?: RtClientOptions): Promise<RtResponse<{
     cursor: number;
 }>>;

package/dist/commands.d.ts

@@ -40,6 +40,31 @@ export interface MrByBranchData {
     byBranch: Record<string, MrByBranchEntry | null>;
     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";
 export interface ForgeTokenData {
@@ -71,6 +96,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 {
     id: number;
@@ -87,10 +114,39 @@ 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;
 }
 export type Attention = {
     needs: boolean;
-    reason: "failed" | "stale" | "stranded" | null;
+    reason: "failed" | "stale" | "stranded" | "blocked" | null;
     evidence: string;
 };
 export interface RunSummary {
@@ -115,6 +171,21 @@ 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;
@@ -313,6 +384,7 @@ export interface Commands {
             room: string;
             handle: string;
             body: string;
+            mentions?: string[];
         };
         data: {
             id: number;
@@ -370,18 +442,21 @@ export interface Commands {
         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>;
     };
@@ -399,6 +474,79 @@ export interface Commands {
             }[];
         };
     };
+    "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;
 export declare const COMMAND_NAMES: readonly CommandName[];

package/dist/health.d.ts

@@ -0,0 +1,11 @@
+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 declare function daemonHealth(opts?: RtClientOptions): Promise<{
+    reachable: boolean;
+    error?: string;
+}>;

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 export { rtCommand, DEFAULT_SOCK } from "./transport.ts";
 export type { RtResponse, RtClientOptions } from "./transport.ts";
-export { readProjectMRs, readDiscussions, readMrsByBranch, resolveForgeToken, listRuns, getRun, abandonRun, chatJoin, chatLeave, chatPost, chatRead, chatRooms, chatWho, chatMark, chatMessages, chatArm, chatTouch, chatDisarm, chatUnreadWaking, eventsHead, } from "./client.ts";
+export { readProjectMRs, readDiscussions, readMrsByBranch, readBranchCache, resolveForgeToken, listRuns, getRun, abandonRun, chatJoin, chatLeave, chatPost, chatRead, chatRooms, chatWho, chatMark, chatMessages, chatArm, chatTouch, chatDisarm, chatUnreadWaking, chatSignIn, chatSignOut, chatAway, chatBack, chatBuddies, chatPulse, chatDm, eventsHead, } from "./client.ts";
 export { COMMAND_NAMES } from "./commands.ts";
-export type { Discussion, DemandDecl, ProjectMRsScope, ProjectMRsData, DiscussionsData, MrByBranchEntry, MrByBranchData, Commands, CommandName, ForgeSlug, ForgeTokenData, Attention, RunSummary, RunStageRow, RunFieldRow, RunDecisionRow, RunDetail, WakeMode, ChatMember, ChatMessage, RoomSummary, } from "./commands.ts";
-export { subscribe, DEFAULT_WS_URL } from "./relay.ts";
+export type { Discussion, DemandDecl, ProjectMRsScope, ProjectMRsData, DiscussionsData, MrByBranchEntry, MrByBranchData, BranchEnrichment, Commands, CommandName, ForgeSlug, ForgeTokenData, Attention, RunSummary, RunStageRow, RunFieldRow, RunDecisionRow, RunDetail, WakeMode, ChatMember, ChatMessage, RoomSummary, BuddyStatus, PresenceRow, } from "./commands.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";
 export { getSetting, listSettings, explainSetting, expandVariables, SCOPE_ORDER } from "./settings/resolve.ts";
 export type { Scope, Provenance, ResolveOpts, Resolved, InvalidScope, ListedSetting, ExplainRow, ExpandCtx, } from "./settings/resolve.ts";

package/dist/index.js

@@ -39,6 +39,9 @@ function readDiscussions(repoName, iid, opts = {}) {
 function readMrsByBranch(repoName, branches, opts = {}) {
   return rtCommand("mr:by-branch", { repoName, branches }, { sockPath: opts.sockPath, timeoutMs: 60000 });
 }
+function readBranchCache(branches, opts = {}) {
+  return rtCommand("cache:read", { branches }, { sockPath: opts.sockPath, timeoutMs: 1e4 });
+}
 function resolveForgeToken(repoName, forge, opts = {}) {
   return rtCommand("secrets:forge-token", { repoName, forge }, { sockPath: opts.sockPath, timeoutMs: 1e4 });
 }
@@ -70,13 +73,16 @@ function chatJoin(a, o = {}) {
     payload.cwd = a.cwd;
   if (a.pane !== undefined)
     payload.pane = a.pane;
-  return rtCommand("chat:join", payload, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:join", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatLeave(a, o = {}) {
-  return rtCommand("chat:leave", { room: a.room, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:leave", { room: a.room, handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatPost(a, o = {}) {
-  return rtCommand("chat:post", { room: a.room, handle: a.handle, body: a.body }, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  const payload = { room: a.room, handle: a.handle, body: a.body };
+  if (a.mentions !== undefined)
+    payload.mentions = a.mentions;
+  return rtCommand("chat:post", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatRead(a, o = {}) {
   const payload = { handle: a.handle };
@@ -86,19 +92,19 @@ function chatRead(a, o = {}) {
     payload.limit = a.limit;
   if (a.sinceMs !== undefined)
     payload.sinceMs = a.sinceMs;
-  return rtCommand("chat:read", payload, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:read", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatRooms(a, o = {}) {
-  return rtCommand("chat:rooms", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:rooms", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatWho(a, o = {}) {
-  return rtCommand("chat:who", { room: a.room }, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:who", { room: a.room }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatMark(a, o = {}) {
   const payload = { handle: a.handle };
   if (a.room !== undefined)
     payload.room = a.room;
-  return rtCommand("chat:mark", payload, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:mark", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatMessages(a, o = {}) {
   const payload = { room: a.room };
@@ -106,28 +112,80 @@ function chatMessages(a, o = {}) {
     payload.before = a.before;
   if (a.limit !== undefined)
     payload.limit = a.limit;
-  return rtCommand("chat:messages", payload, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:messages", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatArm(a, o = {}) {
   const payload = { handle: a.handle };
   if (a.room !== undefined)
     payload.room = a.room;
-  return rtCommand("chat:arm", payload, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  if (a.sessionId !== undefined)
+    payload.sessionId = a.sessionId;
+  return rtCommand("chat:arm", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatTouch(a, o = {}) {
-  return rtCommand("chat:touch", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  const payload = { handle: a.handle };
+  if (a.sessionId !== undefined)
+    payload.sessionId = a.sessionId;
+  return rtCommand("chat:touch", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatDisarm(a, o = {}) {
-  return rtCommand("chat:disarm", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  const payload = { handle: a.handle };
+  if (a.sessionId !== undefined)
+    payload.sessionId = a.sessionId;
+  return rtCommand("chat:disarm", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function chatUnreadWaking(a, o = {}) {
   const payload = { handle: a.handle };
   if (a.room !== undefined)
     payload.room = a.room;
-  return rtCommand("chat:unread-waking", payload, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("chat:unread-waking", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatSignIn(a, o = {}) {
+  const payload = { 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("chat:sign-in", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatSignOut(a, o = {}) {
+  return rtCommand("chat:sign-out", { sessionId: a.sessionId }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatAway(a, o = {}) {
+  return rtCommand("chat:away", { sessionId: a.sessionId, text: a.text }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatBack(a, o = {}) {
+  return rtCommand("chat:back", { sessionId: a.sessionId }, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatBuddies(o = {}) {
+  return rtCommand("chat:buddies", {}, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatPulse(a, o = {}) {
+  const payload = { 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("chat:pulse", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
+}
+function chatDm(a, o = {}) {
+  const payload = { from: a.from, to: a.to, body: a.body };
+  if (a.sessionId !== undefined)
+    payload.sessionId = a.sessionId;
+  return rtCommand("chat:dm", payload, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 function eventsHead(o = {}) {
-  return rtCommand("events:head", {}, { sockPath: o.sockPath, timeoutMs: 1e4 });
+  return rtCommand("events:head", {}, { sockPath: o.sockPath, timeoutMs: o.timeoutMs ?? 1e4 });
 }
 // src/commands.ts
 var COMMAND_NAMES = [
@@ -154,7 +212,14 @@ var COMMAND_NAMES = [
   "chat:arm",
   "chat:touch",
   "chat:disarm",
-  "chat:unread-waking"
+  "chat:unread-waking",
+  "chat:sign-in",
+  "chat:sign-out",
+  "chat:away",
+  "chat:back",
+  "chat:buddies",
+  "chat:pulse",
+  "chat:dm"
 ];
 // src/relay.ts
 var DEFAULT_WS_URL = "ws://127.0.0.1:9401/ws";
@@ -199,6 +264,25 @@ function subscribe(onEvent, opts = {}) {
     } catch {}
   };
 }
+function createRelay(cfg, opts = {}) {
+  const doSubscribe = opts.subscribeImpl ?? subscribe;
+  return doSubscribe((type, data) => {
+    if (type !== "event")
+      return;
+    const frame = data;
+    if (typeof frame?.topic !== "string" || !cfg.match(frame.topic))
+      return;
+    const payload = JSON.stringify(data);
+    try {
+      cfg.publish(cfg.topic, payload);
+    } catch {}
+  }, opts);
+}
+// src/health.ts
+async function daemonHealth(opts = {}) {
+  const res = await eventsHead(opts);
+  return { reachable: res.ok, error: res.ok ? undefined : res.error };
+}
 // src/repos.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir as homedir2 } from "os";
@@ -506,6 +590,13 @@ var REGISTRY = [
     merge: "replace",
     description: "Absolute path to the installed mattstack.app bundle, written by the app at launch so rt stops hardcoding ~/Applications."
   },
+  {
+    key: "mattstack.mode",
+    type: "string",
+    scopes: ["machine"],
+    merge: "replace",
+    description: 'The machine\'s intended flavor, "dev" or "prod". Normally written by `rt settings dev-mode` after a successful handoff; a manual `rt settings set` is the blessed repair escape hatch — the daemon park loop converges on whatever this says. Unset ⇒ derived from the dev wrapper\'s presence.'
+  },
   {
     key: "rt.integrations",
     type: "object",
@@ -1395,7 +1486,7 @@ async function runCapture(argv, opts = {}) {
   }
 }
 
-// src/settings/identity.ts
+// src/settings/identity-codec.ts
 var URL_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^@/]+@)?([^/]+)\/(.+)$/;
 var SCP_RE = /^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/;
 function serializeIdentity(id) {
@@ -1443,6 +1534,8 @@ function normalizeRemote(remote) {
     return null;
   return `${host.toLowerCase()}/${normalizedPath}`;
 }
+
+// src/settings/identity.ts
 function identityFromRemote(remote) {
   const store = readStore(machineSettingsPath());
   const overrides = store.global["rt.repoIdentityOverrides"];
@@ -1522,6 +1615,7 @@ export {
   readProjectMRs,
   readMrsByBranch,
   readDiscussions,
+  readBranchCache,
   parseIdentity,
   normalizeRemote,
   listTeams,
@@ -1536,18 +1630,27 @@ export {
   expandVariables,
   eventsHead,
   deriveRepoIdentity,
+  daemonHealth,
+  createRelay,
   clearIdentityMemo,
   chatWho,
   chatUnreadWaking,
   chatTouch,
+  chatSignOut,
+  chatSignIn,
   chatRooms,
   chatRead,
+  chatPulse,
   chatPost,
   chatMessages,
   chatMark,
   chatLeave,
   chatJoin,
+  chatDm,
   chatDisarm,
+  chatBuddies,
+  chatBack,
+  chatAway,
   chatArm,
   allDefs,
   abandonRun,

package/dist/relay.d.ts

@@ -13,3 +13,18 @@ export declare const DEFAULT_WS_URL = "ws://127.0.0.1:9401/ws";
  * the daemon being down just means silence, never a crash.
  */
 export declare function subscribe(onEvent: (type: RelayEventType, data: unknown) => void, opts?: RtClientOptions): () => void;
+/**
+ * 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 declare function createRelay(cfg: {
+    match: (topic: string) => boolean;
+    topic: string;
+    publish: (topic: string, data: string) => void;
+}, opts?: RtClientOptions): () => void;

package/dist/settings/identity-codec.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+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;

package/dist/settings/identity-codec.js

@@ -0,0 +1,53 @@
+// src/settings/identity-codec.ts
+var URL_RE = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\/(?:[^@/]+@)?([^/]+)\/(.+)$/;
+var SCP_RE = /^(?:[^@/\s]+@)?([^:/\s]+):(.+)$/;
+function serializeIdentity(id) {
+  return `${id.kind}:${encodeURIComponent(id.id)}`;
+}
+function parseIdentity(wire) {
+  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;
+  try {
+    id = decodeURIComponent(encoded);
+  } catch {
+    return null;
+  }
+  if (encodeURIComponent(id) !== encoded)
+    return null;
+  return { kind, id };
+}
+function normalizeRemote(remote) {
+  const trimmed = remote.trim();
+  if (!trimmed)
+    return null;
+  let host;
+  let path;
+  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}`;
+}
+export {
+  serializeIdentity,
+  parseIdentity,
+  normalizeRemote
+};