@mattstack/rt-client 0.2.0 → 0.4.0

package/src/client.ts

@@ -5,7 +5,20 @@
  */
 import { rtCommand } from "./transport.ts";
 import type { RtResponse, RtClientOptions } from "./transport.ts";
-import type { DemandDecl, ProjectMRsData, DiscussionsData, MrByBranchData, ForgeSlug, ForgeTokenData } from "./commands.ts";
+import type {
+  DemandDecl,
+  ProjectMRsData,
+  DiscussionsData,
+  MrByBranchData,
+  ForgeSlug,
+  ForgeTokenData,
+  RunSummary,
+  RunDetail,
+  WakeMode,
+  ChatMember,
+  ChatMessage,
+  RoomSummary,
+} from "./commands.ts";
 
 /**
  * One repo's project open-MR store. A cold repo forces a full paginated sync
@@ -58,7 +71,7 @@ export function readMrsByBranch(
  * side: an untracked repo comes back `ok: false` with the `rt daemon track`
  * command to run, which is the fail-closed shape callers should surface
  * verbatim. Callers keep env-var precedence on their own side; this is the
- * fallback that replaces reading ~/.rt/secrets.json directly.
+ * fallback that replaces reading ~/.mattstack/rt/secrets.json directly.
  */
 export function resolveForgeToken(
   repoName: string,
@@ -71,3 +84,149 @@ export function resolveForgeToken(
     { sockPath: opts.sockPath, timeoutMs: 10_000 },
   );
 }
+
+export function listRuns(
+  repo?: string,
+  opts: RtClientOptions = {},
+): Promise<RtResponse<{ runs: RunSummary[] }>> {
+  const payload: Record<string, unknown> = {};
+  if (repo !== undefined) payload.repo = repo;
+  return rtCommand<{ runs: RunSummary[] }>("runs:list", payload, { sockPath: opts.sockPath, timeoutMs: 10_000 });
+}
+
+export function getRun(
+  runId: string,
+  repo?: string,
+  opts: RtClientOptions = {},
+): Promise<RtResponse<RunDetail>> {
+  const payload: Record<string, unknown> = { runId };
+  if (repo !== undefined) payload.repo = repo;
+  return rtCommand<RunDetail>("runs:get", payload, { sockPath: opts.sockPath, timeoutMs: 10_000 });
+}
+
+/**
+ * SKILLS-54. rt's only write path into run state, so a wedged run can be
+ * resolved by a person instead of lying in the data forever. The write happens
+ * in the daemon and is attributed there; consumers never touch the run DB.
+ */
+export function abandonRun(
+  runId: string,
+  repo?: string,
+  reason?: string,
+  opts: RtClientOptions = {},
+): Promise<RtResponse<{ ok: boolean }>> {
+  const payload: Record<string, unknown> = { runId };
+  if (repo !== undefined) payload.repo = repo;
+  if (reason !== undefined) payload.reason = reason;
+  return rtCommand<{ ok: boolean }>("runs:abandon", payload, { sockPath: opts.sockPath, timeoutMs: 10_000 });
+}
+
+// ─── Chat (RT-48 Task 6) ──────────────────────────────────────────────────
+// The web viewer's (plan 2's) entire dependency: it reaches the daemon
+// through these wrappers over the unix socket, so no /api/chat/* REST rows
+// ship and needsToken() stays untouched.
+
+export function chatJoin(
+  a: { room: string; handle: string; wakeOn?: WakeMode; cwd?: string; pane?: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ handle: string; memberCount: number; unread: number }>> {
+  const payload: Record<string, unknown> = { room: a.room, handle: a.handle };
+  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 });
+}
+
+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 });
+}
+
+export function chatPost(
+  a: { room: string; handle: string; body: 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 });
+}
+
+export function chatRead(
+  a: { handle: string; room?: string; limit?: number; sinceMs?: number },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ rooms: { room: string; messages: ChatMessage[] }[] }>> {
+  const payload: Record<string, unknown> = { handle: a.handle };
+  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 });
+}
+
+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 });
+}
+
+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 });
+}
+
+export function chatMark(
+  a: { handle: string; room?: 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:mark", payload, { sockPath: o.sockPath, timeoutMs: 10_000 });
+}
+
+export function chatMessages(
+  a: { room: string; before?: number; limit?: number },
+  o: RtClientOptions = {},
+): Promise<RtResponse<{ messages: ChatMessage[] }>> {
+  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 });
+}
+
+export function chatArm(
+  a: { handle: string; room?: 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 });
+}
+
+export function chatTouch(
+  a: { handle: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<Record<string, never>>> {
+  return rtCommand<Record<string, never>>("chat:touch", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+}
+
+export function chatDisarm(
+  a: { handle: string },
+  o: RtClientOptions = {},
+): Promise<RtResponse<Record<string, never>>> {
+  return rtCommand<Record<string, never>>("chat:disarm", { handle: a.handle }, { sockPath: o.sockPath, timeoutMs: 10_000 });
+}
+
+export function chatUnreadWaking(
+  a: { handle: string; room?: string },
+  o: RtClientOptions = {},
+): 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 });
+}
+
+export function eventsHead(o: RtClientOptions = {}): Promise<RtResponse<{ cursor: number }>> {
+  return rtCommand<{ cursor: number }>("events:head", {}, { sockPath: o.sockPath, timeoutMs: 10_000 });
+}

package/src/commands.ts

@@ -52,6 +52,84 @@ export interface ForgeTokenData {
   token: string;
 }
 
+/**
+ * Duplicated shape on purpose (RT-44): rt-client cannot import daemon
+ * internals, so this mirrors lib/daemon/events-bus.ts's BusEvent.
+ */
+export interface EventsBusEvent { id: number; topic: string; payload: unknown; emittedAt: number }
+
+/**
+ * Duplicated shape on purpose, same reasoning as EventsBusEvent above:
+ * these mirror lib/state/chat-store.ts's types, which rt-client cannot
+ * import (it's outside lib/state/ and outside this package entirely).
+ */
+export type WakeMode = "mention" | "all" | "none";
+
+export interface ChatMember {
+  room: string;
+  handle: string;
+  joinedAt: number;
+  lastReadId: number;
+  wakeOn: WakeMode;
+  lastSeenAt?: number;
+  armedAt?: number;
+  cwd?: string;
+  pane?: string;
+}
+
+export interface ChatMessage {
+  id: number;
+  room: string;
+  handle: string;
+  body: string;
+  mentions: string[];
+  replyTo?: number;
+  postedAt: number;
+}
+
+export interface RoomSummary {
+  room: string;
+  memberCount: number;
+  unread: number;
+  mentions: number;
+  lastPostedAt?: 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;
+  evidence: string;
+};
+
+export interface RunSummary {
+  id: string; repo: string; work_type: string; pipeline: string;
+  status: string; current_stage: string | null; spawned_by: string | null;
+  started_at: number; ended_at: number | null;
+  // v2. Null on runs written before schema v2; pack_dirty means the pack tree
+  // had uncommitted changes, so the as-run text may exist in no commit.
+  pack_commits: string | null; pack_dirty: number;
+  attention: Attention;
+  /** Max over stage, field, and decision timestamps; falls back to
+      `started_at` when the run has produced no events yet. The board orders
+      by silence, so this — not `started_at` — is its sort key. */
+  last_event_at: number;
+  /** Denormalized from the run's `ticket` / `branch` fields so the LIST view
+      can render and search them without a detail fetch per row. Null when
+      the run has not produced that field yet. */
+  ticket: string | null;
+  branch: string | null;
+}
+export interface RunStageRow {
+  name: string; status: string; attempt: number;
+  started_at: number | null; ended_at: number | null;
+  reason: string | null; detail_path: string | null;
+}
+export interface RunFieldRow { key: string; value: string; produced_by: string; at: number; }
+export interface RunDecisionRow { contract: string; scope: string; selection: string; decided_by: string; decided_at: number; }
+export interface RunDetail { run: RunSummary; stages: RunStageRow[]; fields: RunFieldRow[]; decisions: RunDecisionRow[]; schemaAhead: boolean; }
+
 export interface Commands {
   "project-mrs:read": { payload: { repoName: string; maxAgeMs?: number; demand?: DemandDecl }; data: ProjectMRsData };
   "discussions:read": { payload: { repoName: string; iid: number }; data: DiscussionsData };
@@ -59,11 +137,67 @@ export interface Commands {
   /**
    * The forge token for one tracked repo (MAT-33). Repo-scoped on purpose:
    * rt gates access per repo through repo-tracking.json, and this verb is
-   * what lets consumers stop reading ~/.rt/secrets.json directly, which
+   * what lets consumers stop reading ~/.mattstack/rt/secrets.json directly, which
    * walked around that grant model entirely. An untracked repo is refused;
    * the caller's env vars keep precedence on the caller's side.
    */
   "secrets:forge-token": { payload: { repoName: string; forge: ForgeSlug }; data: ForgeTokenData };
+  /**
+   * A per-`scope` whitelisted subset of secrets, each scope reading its own
+   * encrypted domain(s): "extension" (default, so the VS Code extension
+   * needs no change) is linearApiKey/gitlabToken from the `rt` domain;
+   * "deck" is cfApiToken/cfZoneId from the `deck` domain; "board" is
+   * cross-domain — slackToken/slackClientSecret/slackSigningSecret from the
+   * `board` domain plus gitlabToken/switchboardToken/switchboardAdminToken
+   * from the `rt` domain. `data` is a union of the per-scope shapes, not a
+   * merged bag of every key — that makes a caller narrowing on the wrong
+   * scope's fields a compile error instead of a silent `undefined`. Every
+   * key optional (present only when set). Not a general secrets export —
+   * extend a whitelist here, in lockstep with
+   * lib/daemon/handlers/secrets.ts and (for "extension")
+   * extensions/vscode/rt-context/src/secrets.ts, if a consumer needs another
+   * key.
+   *
+   * `token` is required and checked in the HANDLER (not a transport-layer
+   * gate alone), since this verb is reachable over the unauthenticated unix
+   * socket too — see lib/daemon/handlers/secrets.ts's doc comment. HTTP
+   * callers get it forwarded automatically from their X-RT-Token header;
+   * socket callers must read ~/.mattstack/rt/api-token themselves. The gate
+   * applies identically to every scope.
+   */
+  "secrets:read": {
+    payload: { token?: string; scope?: "extension" | "deck" | "board" };
+    data:
+      | { linearApiKey?: string; gitlabToken?: string }
+      | { cfApiToken?: string; cfZoneId?: string }
+      | {
+          slackToken?: string;
+          slackClientSecret?: string;
+          slackSigningSecret?: string;
+          gitlabToken?: string;
+          switchboardToken?: string;
+          switchboardAdminToken?: string;
+        };
+  };
+  "events:emit": { payload: { topic: string; payload?: unknown }; data: { id: number } };
+  "events:wait": { payload: { pattern: string; after?: number; waitMs?: number }; data: { events: EventsBusEvent[]; cursor: number } };
+  "events:list": { payload: { pattern: string; after?: number; limit?: number }; data: { events: EventsBusEvent[]; cursor: number } };
+  "events:head": { payload: Record<string, never>; data: { cursor: number } };
+  "runs:list": { payload: { repo?: string }; data: { runs: RunSummary[] } };
+  "runs:get": { payload: { runId: string; repo?: string }; data: RunDetail };
+  "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: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:unread-waking": { payload: { handle: string; room?: string }; data: { rooms: { room: string; count: number; mentions: number; maxId: number }[] } };
 }
 
 export type CommandName = keyof Commands;
@@ -73,4 +207,24 @@ export const COMMAND_NAMES: readonly CommandName[] = [
   "discussions:read",
   "mr:by-branch",
   "secrets:forge-token",
+  "secrets:read",
+  "events:emit",
+  "events:wait",
+  "events:list",
+  "events:head",
+  "runs:list",
+  "runs:get",
+  "runs:abandon",
+  "chat:join",
+  "chat:leave",
+  "chat:post",
+  "chat:read",
+  "chat:rooms",
+  "chat:who",
+  "chat:mark",
+  "chat:messages",
+  "chat:arm",
+  "chat:touch",
+  "chat:disarm",
+  "chat:unread-waking",
 ];

package/src/index.ts

@@ -1,7 +1,28 @@
 export { rtCommand, DEFAULT_SOCK } from "./transport.ts";
 export type { RtResponse, RtClientOptions } from "./transport.ts";
 
-export { readProjectMRs, readDiscussions, readMrsByBranch, resolveForgeToken } from "./client.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 { COMMAND_NAMES } from "./commands.ts";
 export type {
@@ -16,9 +37,49 @@ export type {
   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 { RelayEventType } from "./relay.ts";
 
 export { repoNameForPath } from "./repos.ts";
+
+// ─── Settings (RT-50) ────────────────────────────────────────────────────────
+
+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";
+
+export { setSetting } from "./settings/write.ts";
+export type { SetSettingOpts } from "./settings/write.ts";
+
+export { getDef, allDefs, validateValue, isMigrated } from "./settings/registry-machinery.ts";
+export type { SettingDef, SettingScope } from "./settings/registry-machinery.ts";
+export { REGISTRY } from "./settings/registry-defs.ts";
+
+export { readStore, listTeams } from "./settings/stores.ts";
+export type { StoreFile } from "./settings/stores.ts";
+
+export {
+  normalizeRemote, identityFromRemote, deriveRepoIdentity, clearIdentityMemo,
+  serializeIdentity, parseIdentity, resolveNameToIdentity,
+  type RepoIdentity,
+} from "./settings/identity.ts";

package/src/repos.ts

@@ -1,28 +1,83 @@
 /**
- * Repo-name resolution against rt's global index (~/.rt/repos.json), a flat
- * `{ "<repoName>": "<absolute path>" }` map. Lets a client resolve "what
- * directory am I in" to "what does the daemon call this repo" without
- * maintaining its own copy of the mapping.
+ * Repo-name resolution against rt's global index. rt itself resolves this
+ * through state.db (~/.mattstack/rt/state.db); this module runs OUT OF
+ * PROCESS (gitq, mr-board, deck), so it has no handle on that db and reads
+ * a derived snapshot instead — state.db's kv `repo-index` namespace when
+ * reachable, falling back to the legacy `repos.json` mirror
+ * (~/.mattstack/rt/repos.json, a flat `{ "<repoName>": "<absolute path>" }`
+ * map) rt keeps in sync for exactly this purpose. See rt's
+ * lib/repo-index.ts `repoIndexCompatPath` for the write side.
  */
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { dirname, join } from "path";
 
 function defaultReposJsonPath(): string {
-  return join(homedir(), ".rt", "repos.json");
+  // Duplicates the ~/.mattstack/rt layout: rt-client has no dependency on rt's
+  // lib/, so this literal cannot import rtDir(). repo-tools/lib/rt-paths.ts is
+  // the authority — change there first, mirror here.
+  return join(homedir(), ".mattstack", "rt", "repos.json");
 }
 
+interface RepoIndexRow {
+  k: string;
+  v: string;
+}
+
+interface BunSqliteDatabase {
+  query(sql: string): { all(...params: unknown[]): unknown[] };
+  close(): void;
+}
+
+type BunSqliteDatabaseCtor = new (path: string, opts?: { readonly?: boolean }) => BunSqliteDatabase;
+
 /**
- * Exact-match lookup: returns the repo name whose recorded path equals
- * `repoPath`, or null if the file is missing, corrupt, or has no match.
- * Never throws -- a resolution failure just means the caller falls back to
- * whatever it had before (an unqualified path, a prompt, etc).
+ * Loads bun:sqlite defensively: only Bun's runtime provides this built-in.
+ * A non-Bun consumer throws resolving the specifier, caught here so the
+ * caller degrades to the repos.json path instead of throwing.
  */
-export function repoNameForPath(repoPath: string, reposJsonPath?: string): string | null {
-  const path = reposJsonPath ?? defaultReposJsonPath();
+function loadBunSqliteDatabase(): BunSqliteDatabaseCtor | null {
+  try {
+    return (require("bun:sqlite") as { Database: BunSqliteDatabaseCtor }).Database;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Exact-match lookup against state.db's `repo-index` kv namespace (ns=k=v
+ * rows written by rt's setKvValue, so `v` is a JSON-encoded string). Returns
+ * null (never throws) on any failure — missing db, unreadable, wrong
+ * schema, no match — so the caller always has repos.json as a fallback.
+ */
+function repoNameFromStateDb(repoPath: string, dbPath: string): string | null {
+  if (!existsSync(dbPath)) return null;
+  const DatabaseCtor = loadBunSqliteDatabase();
+  if (!DatabaseCtor) return null;
+  try {
+    const db = new DatabaseCtor(dbPath, { readonly: true });
+    try {
+      const rows = db.query("SELECT k, v FROM kv WHERE ns = 'repo-index';").all() as RepoIndexRow[];
+      for (const row of rows) {
+        try {
+          if (JSON.parse(row.v) === repoPath) return row.k;
+        } catch {
+          continue;
+        }
+      }
+      return null;
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
+
+function repoNameFromJson(repoPath: string, reposJsonPath: string): string | null {
   try {
-    if (!existsSync(path)) return null;
-    const raw = readFileSync(path, "utf8");
+    if (!existsSync(reposJsonPath)) return null;
+    const raw = readFileSync(reposJsonPath, "utf8");
     const index = JSON.parse(raw) as Record<string, unknown>;
     for (const [repoName, value] of Object.entries(index)) {
       if (value === repoPath) return repoName;
@@ -32,3 +87,23 @@ export function repoNameForPath(repoPath: string, reposJsonPath?: string): strin
     return null;
   }
 }
+
+/**
+ * Exact-match lookup: returns the repo name whose recorded path equals
+ * `repoPath`, or null if no source has a match. Never throws -- a
+ * resolution failure just means the caller falls back to whatever it had
+ * before (an unqualified path, a prompt, etc).
+ *
+ * Prefers state.db (authoritative, kept live by every rt process); falls
+ * back to the repos.json compat mirror when state.db is unreachable — a
+ * pre-upgrade rt install, a non-Bun consumer, or a state.db this process
+ * can't open. `reposJsonPath`, when passed, also relocates the state.db
+ * lookup: both files live side by side under the same rt data directory.
+ */
+export function repoNameForPath(repoPath: string, reposJsonPath?: string): string | null {
+  const jsonPath = reposJsonPath ?? defaultReposJsonPath();
+  const dbPath = join(dirname(jsonPath), "state.db");
+  const fromDb = repoNameFromStateDb(repoPath, dbPath);
+  if (fromDb !== null) return fromDb;
+  return repoNameFromJson(repoPath, jsonPath);
+}

package/src/settings/exec.ts

@@ -0,0 +1,67 @@
+/**
+ * Async subprocess capture, duplicated from repo-tools/lib/subprocess.ts:
+ * rt-client has no dependency on rt's lib/, so this can't import runCapture
+ * from there. lib/subprocess.ts is the authority — change there first,
+ * mirror here.
+ *
+ * execSync blocks the event loop for the entire child lifetime; identity
+ * derivation must stay safe to call from daemon contexts, hence this instead.
+ */
+
+export interface RunResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+/**
+ * Run argv and capture stdout. Never throws: spawn failures and timeouts
+ * surface as a non-zero exitCode with whatever stdout was collected.
+ *
+ * Children inherit the caller's live `process.env` unless `opts.env` overrides it.
+ */
+export async function runCapture(
+  argv: [string, ...string[]],
+  opts: {
+    cwd?: string;
+    timeoutMs?: number;
+    stderr?: "ignore" | "pipe";
+    env?: Record<string, string | undefined>;
+  } = {},
+): Promise<RunResult> {
+  const captureStderr = opts.stderr === "pipe";
+  let proc: ReturnType<typeof Bun.spawn>;
+  try {
+    proc = Bun.spawn(argv, {
+      cwd: opts.cwd,
+      // Bun.spawn ignores assignments made to process.env after startup, so an
+      // inherited env strands a PATH resolved at boot and leaves
+      // `#!/usr/bin/env node` shebangs unresolvable under launchd. execSync,
+      // which this replaces, reads process.env per call.
+      env: opts.env ?? { ...process.env },
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: captureStderr ? "pipe" : "ignore",
+    });
+  } catch {
+    return { stdout: "", stderr: "", exitCode: -1 };
+  }
+
+  const timer = setTimeout(() => {
+    try { proc.kill(); } catch { /* already exited */ }
+  }, opts.timeoutMs ?? 10_000);
+
+  try {
+    const stdoutPromise = new Response(proc.stdout as ReadableStream).text();
+    const stderrPromise = captureStderr
+      ? new Response(proc.stderr as ReadableStream).text()
+      : Promise.resolve("");
+    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+    const exitCode = await proc.exited;
+    return { stdout, stderr, exitCode };
+  } catch {
+    return { stdout: "", stderr: "", exitCode: -1 };
+  } finally {
+    clearTimeout(timer);
+  }
+}