arp-tui 0.0.5 → 0.0.7

package/dist/index.js

@@ -5,7 +5,7 @@ import { parseArgs as nodeParseArgs } from "util";
 import { render } from "ink";
 
 // src/app.tsx
-import { Box as Box8, Text as Text10, useApp, useInput, useStdin } from "ink";
+import { Box as Box9, Text as Text11, useApp, useInput, useStdin } from "ink";
 import { useEffect, useSyncExternalStore } from "react";
 
 // src/state/store.ts
@@ -621,7 +621,7 @@ function chooseRefreshToken(args2) {
   const { memoryRt, diskRt, memorySub, diskSub, knownNewerInMemory } = args2;
   const memNewerThanDisk = knownNewerInMemory && diskRt !== memoryRt;
   if (memNewerThanDisk) {
-    if (diskRt === null && diskSub && memorySub && diskSub !== memorySub) return null;
+    if (diskSub && memorySub && diskSub !== memorySub) return null;
     return memoryRt;
   }
   const sameIdentity = diskRt === memoryRt || !!diskSub && diskSub === memorySub;
@@ -780,6 +780,239 @@ async function logout(instance2, log = console.error) {
   return true;
 }
 
+// src/commands/result.ts
+var EXIT_CODE = {
+  success: 0,
+  internal_error: 1,
+  usage: 2,
+  cancelled: 3,
+  authentication_required: 4,
+  policy_denied: 5,
+  bridge_unavailable: 6,
+  relay_unavailable: 7,
+  configured_offline: 8,
+  outcome_unknown: 9,
+  local_integrity_error: 10
+};
+var MAX_SAFE_MESSAGE_SCALARS = 256;
+var SAFE_CODE = /^[a-z][a-z0-9_]{0,63}$/;
+function boundedText(value) {
+  const plain = value.replace(/\r\n?|\n/g, " ").replace(/[\x00-\x1f\x7f-\x9f]/g, "").normalize("NFC");
+  return Array.from(plain).slice(0, MAX_SAFE_MESSAGE_SCALARS).join("");
+}
+var CommandFailure = class extends Error {
+  exitCode;
+  stableCode;
+  operationId;
+  requestId;
+  constructor(symbol, stableCode, message, refs) {
+    if (!SAFE_CODE.test(stableCode)) throw new TypeError("invalid stable error code");
+    super(boundedText(message));
+    this.name = "CommandFailure";
+    this.exitCode = EXIT_CODE[symbol];
+    this.stableCode = stableCode;
+    this.operationId = refs?.operationId;
+    this.requestId = refs?.requestId;
+  }
+  toJSON() {
+    return Object.freeze({
+      schemaVersion: 1,
+      ok: false,
+      code: this.stableCode,
+      message: this.message,
+      ...this.operationId ? { operationId: this.operationId } : {},
+      ...this.requestId ? { requestId: this.requestId } : {}
+    });
+  }
+};
+var OutcomeUnknown = class extends CommandFailure {
+  operation;
+  reconcile;
+  constructor(args2) {
+    super(
+      "outcome_unknown",
+      "outcome_unknown",
+      "The relay outcome is unknown. Reconcile this operation before trying again.",
+      { operationId: args2.operationId, requestId: args2.requestId }
+    );
+    this.name = "OutcomeUnknown";
+    this.operation = args2.operation;
+    this.reconcile = args2.reconcile;
+  }
+  toJSON() {
+    return Object.freeze({ ...super.toJSON(), operation: boundedText(this.operation), reconcile: boundedText(this.reconcile) });
+  }
+};
+
+// src/util/sanitize.ts
+var ESCAPE_SEQ = (
+  // eslint-disable-next-line no-control-regex
+  /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][\s\S]*?(?:\x07|\x1b\\)|[PX^_][\s\S]*?\x1b\\|[@-Z\\-_])/g
+);
+var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f]/g;
+function sanitizeForTty(input) {
+  return input.replace(ESCAPE_SEQ, "").replace(CONTROL_CHARS, "");
+}
+function sanitizeLabel(input, max = 40) {
+  const clean = sanitizeForTty(input);
+  return clean.length > max ? clean.slice(0, max - 1) + "\u2026" : clean;
+}
+var FORMAT_CONTROLS = /[\u00ad\u034f\u061c\u115f-\u1160\u17b4-\u17b5\u180b-\u180f\u200b-\u200f\u202a-\u202e\u2060-\u206f\u3164\ufe00-\ufe0f\ufeff\uffa0\ufff0-\ufff8\u{1bca0}-\u{1bca3}\u{1d173}-\u{1d17a}\u{e0000}-\u{e0fff}]/gu;
+function stripTerminalSequences(input) {
+  let out = "";
+  for (let i = 0; i < input.length; ) {
+    const cp = input.codePointAt(i);
+    const width = cp > 65535 ? 2 : 1;
+    const esc = cp === 27;
+    const csi = cp === 155;
+    const osc = cp === 157;
+    const stringControl = cp === 144 || cp === 152 || cp === 158 || cp === 159;
+    if (esc || csi || osc || stringControl) {
+      let kind = cp;
+      i += width;
+      if (esc && i < input.length) {
+        kind = input.codePointAt(i);
+        i += kind > 65535 ? 2 : 1;
+      }
+      if (kind === 91 || kind === 155) {
+        while (i < input.length) {
+          const n = input.codePointAt(i);
+          i += n > 65535 ? 2 : 1;
+          if (n >= 64 && n <= 126) break;
+        }
+      } else if (kind === 93 || kind === 157 || kind === 80 || kind === 88 || kind === 94 || kind === 95 || stringControl) {
+        while (i < input.length) {
+          const n = input.codePointAt(i);
+          i += n > 65535 ? 2 : 1;
+          if ((kind === 93 || kind === 157) && n === 7) break;
+          if (n === 156) break;
+          if (n === 27 && input.codePointAt(i) === 92) {
+            i++;
+            break;
+          }
+        }
+      }
+      continue;
+    }
+    if (cp < 32 && cp !== 9 && cp !== 10 && cp !== 13 || cp >= 127 && cp <= 159) {
+      i += width;
+      continue;
+    }
+    out += String.fromCodePoint(cp);
+    i += width;
+  }
+  return out.replace(FORMAT_CONTROLS, "");
+}
+function clampScalars(value, max) {
+  const points = Array.from(value);
+  return points.length <= max ? value : points.slice(0, max).join("");
+}
+function sanitizeRemoteMultiline(input, maxScalars = 8192) {
+  const normalizedLines = stripTerminalSequences(input).replace(/\r\n?/g, "\n").replace(/\t/g, " ").split("\n").slice(0, 64).map((line) => clampScalars(line, 512)).join("\n").normalize("NFC");
+  return clampScalars(normalizedLines, maxScalars);
+}
+function sanitizeRemoteSingleLine(input, maxScalars = 256) {
+  return clampScalars(
+    stripTerminalSequences(input).replace(/\r\n?|\n|\t/g, " ").normalize("NFC"),
+    maxScalars
+  );
+}
+
+// src/api/attentionMutations.ts
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var ATTENTION_LEVELS = /* @__PURE__ */ new Set(["info", "action_required", "critical"]);
+function requireImmutableId(value, label) {
+  if (!UUID.test(value)) throw new CommandFailure("usage", "invalid_immutable_id", `${label} must be an immutable UUID from a list result.`);
+  return value;
+}
+function invalid(label) {
+  throw new CommandFailure("relay_unavailable", "invalid_relay_response", `The relay returned an invalid ${label}.`);
+}
+function record(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid(label);
+  return value;
+}
+function string(value, label, maxBytes) {
+  if (typeof value !== "string" || Buffer.byteLength(value, "utf8") > maxBytes) invalid(label);
+  return value;
+}
+function uuid(value, label) {
+  const id = string(value, label, 36);
+  if (!UUID.test(id)) invalid(label);
+  return id;
+}
+function timestamp(value, label) {
+  const stamp = string(value, label, 64);
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/.test(stamp)) invalid(label);
+  return stamp;
+}
+function count(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > 1e6) invalid(label);
+  return value;
+}
+function level(value) {
+  if (typeof value !== "string" || !ATTENTION_LEVELS.has(value)) invalid("attention level");
+  return value;
+}
+function optionalActorType(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (value !== "human" && value !== "bot" && value !== "system") invalid("attention attribution type");
+  return value;
+}
+function decodeAttention(value) {
+  const item = record(value, "attention item");
+  const raisedByType = optionalActorType(item.raisedByType);
+  const raisedBy = item.raisedBy === void 0 || item.raisedBy === null ? void 0 : sanitizeRemoteSingleLine(string(item.raisedBy, "attention attribution", 256));
+  return {
+    id: uuid(item.id, "attention id"),
+    channelId: uuid(item.channelId, "attention channel id"),
+    level: level(item.level),
+    reason: sanitizeRemoteMultiline(string(item.reason, "attention reason", 1024)),
+    count: count(item.count, "attention count"),
+    raisedAt: timestamp(item.raisedAt, "attention raised timestamp"),
+    updatedAt: timestamp(item.updatedAt, "attention updated timestamp"),
+    ...raisedBy ? { raisedBy } : {},
+    ...raisedByType ? { raisedByType } : {}
+  };
+}
+function envelope(value, field) {
+  const outer = record(value, "response envelope");
+  if (outer.ok !== true || !(field in outer)) invalid("response envelope");
+  return outer[field];
+}
+var AttentionMutations = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  async listChannel(channelId) {
+    const id = requireImmutableId(channelId, "channel id");
+    return this.transport.request({ method: "GET", path: `/channels/${id}/attention`, operation: "attention.list-channel", decode: (value) => {
+      const items = envelope(value, "attention");
+      if (!Array.isArray(items) || items.length > 64) invalid("attention list");
+      return items.map(decodeAttention);
+    } });
+  }
+  raise(args2) {
+    const channelId = requireImmutableId(args2.channelId, "channel id");
+    return this.transport.request({ method: "POST", path: `/channels/${channelId}/attention`, operation: "attention.raise", operationId: args2.operationId, reconcile: `GET /channels/${channelId}/attention`, body: { level: args2.level, reason: args2.reason, count: 1, sourceTaskIds: [] }, decode: (value) => {
+      const attention = decodeAttention(envelope(value, "attention"));
+      if (attention.channelId !== channelId || attention.level !== args2.level || attention.reason !== sanitizeRemoteMultiline(args2.reason)) invalid("attention receipt");
+      return { attention };
+    } });
+  }
+  ack(args2) {
+    const channelId = requireImmutableId(args2.channelId, "channel id");
+    return this.transport.request({ method: "POST", path: `/channels/${channelId}/attention/ack`, operation: "attention.ack", operationId: args2.operationId, reconcile: `GET /channels/${channelId}/attention`, body: args2.level ? { level: args2.level } : {}, decode: (value) => ({ acked: count(envelope(value, "acked"), "acknowledged count") }) });
+  }
+};
+function normalizeReason(value) {
+  if (Buffer.byteLength(value, "utf8") > 1024) throw new CommandFailure("usage", "reason_too_long", "Attention reason must be at most 1,024 UTF-8 bytes.");
+  const reason = sanitizeRemoteSingleLine(value, 256).trim();
+  if (!reason) throw new CommandFailure("usage", "reason_required", "Attention reason is required.");
+  return reason;
+}
+
 // src/api/clerkRefresh.ts
 var CACHE_TTL_MS = 45e3;
 var FAPI_TIMEOUT_MS = 1e4;
@@ -838,15 +1071,158 @@ function createClerkTokenSupplier(clientToken, opts) {
   };
 }
 
+// src/api/lifecycleTransport.ts
+var DEFAULT_READ_TIMEOUT_MS = 15e3;
+var DEFAULT_MUTATION_TIMEOUT_MS = 2e4;
+var DEFAULT_RESPONSE_LIMIT = 64 * 1024;
+var DEFAULT_REQUEST_LIMIT = 64 * 1024;
+var MAX_JSON_DEPTH = 32;
+var CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function assertJsonDepth(value, depth = 0) {
+  if (depth > MAX_JSON_DEPTH) throw new CommandFailure("relay_unavailable", "invalid_relay_response", "The relay response exceeded the accepted JSON depth.");
+  if (Array.isArray(value)) for (const item of value) assertJsonDepth(item, depth + 1);
+  else if (value && typeof value === "object") for (const item of Object.values(value)) assertJsonDepth(item, depth + 1);
+}
+function requestId(headers) {
+  const value = headers.get("x-request-id") ?? void 0;
+  return value && /^[A-Za-z0-9._:-]{1,128}$/.test(value) ? value : void 0;
+}
+async function readBounded(response, limit) {
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > limit) throw new CommandFailure("relay_unavailable", "response_too_large", "The relay response exceeded the accepted size.", { requestId: requestId(response.headers) });
+      chunks.push(value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+    });
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+var LifecycleTransport = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.origin = new URL(cfg.relayUrl);
+    if (this.origin.protocol !== "https:" || this.origin.username || this.origin.password || this.origin.search || this.origin.hash || this.origin.pathname !== "/") {
+      throw new CommandFailure("local_integrity_error", "invalid_relay_origin", "The selected relay profile has an invalid origin.");
+    }
+    this.fetchImpl = cfg.fetch ?? globalThis.fetch;
+  }
+  cfg;
+  origin;
+  fetchImpl;
+  async request(req) {
+    if (!req.path.startsWith("/") || req.path.startsWith("//") || req.path.length > 2048 || /[\x00-\x20\x7f-\x9f]/u.test(req.path)) throw new CommandFailure("internal_error", "invalid_route", "The lifecycle route is invalid.");
+    const target = new URL(req.path, this.origin);
+    if (target.origin !== this.origin.origin) throw new CommandFailure("internal_error", "cross_origin_route", "The lifecycle route crossed the selected relay origin.");
+    const mutation = req.method !== "GET";
+    if (mutation && (!req.operationId || !CANONICAL_UUID.test(req.operationId) || !req.reconcile)) throw new CommandFailure("internal_error", "missing_operation_identity", "A mutation requires a canonical operation ID and reconciliation method.");
+    const outcomeUnknown = (rid2) => new OutcomeUnknown({
+      operation: req.operation,
+      operationId: req.operationId,
+      requestId: rid2,
+      reconcile: req.reconcile
+    });
+    let token;
+    try {
+      token = await this.cfg.getToken();
+    } catch {
+      throw new CommandFailure("authentication_required", "authentication_required", "Sign in with `arp-tui login`.");
+    }
+    if (!token) throw new CommandFailure("authentication_required", "authentication_required", "Sign in with `arp-tui login`.");
+    let serializedBody;
+    if (req.body !== void 0) {
+      try {
+        serializedBody = JSON.stringify(req.body);
+      } catch {
+        throw new CommandFailure("internal_error", "invalid_request_body", "The lifecycle request body could not be encoded.");
+      }
+      if (Buffer.byteLength(serializedBody, "utf8") > DEFAULT_REQUEST_LIMIT) throw new CommandFailure("internal_error", "request_too_large", "The lifecycle request exceeded the accepted size.");
+    }
+    let response;
+    try {
+      response = await this.fetchImpl(target, {
+        method: req.method,
+        redirect: "manual",
+        headers: {
+          accept: "application/json",
+          authorization: `Bearer ${token}`,
+          ...req.body === void 0 ? {} : { "content-type": "application/json" },
+          ...req.operationId ? { "ARP-Operation-Id": req.operationId } : {}
+        },
+        body: serializedBody,
+        signal: AbortSignal.timeout(mutation ? this.cfg.mutationTimeoutMs ?? DEFAULT_MUTATION_TIMEOUT_MS : this.cfg.readTimeoutMs ?? DEFAULT_READ_TIMEOUT_MS)
+      });
+    } catch {
+      if (mutation) throw outcomeUnknown();
+      throw new CommandFailure("relay_unavailable", "relay_unavailable", "The relay did not return a definitive response.");
+    }
+    const rid = requestId(response.headers);
+    if (response.status >= 300 && response.status < 400) {
+      if (mutation) throw outcomeUnknown(rid);
+      throw new CommandFailure("relay_unavailable", "redirect_refused", "The relay returned a redirect, which was refused.", { requestId: rid });
+    }
+    const contentLength = Number(response.headers.get("content-length") ?? "0");
+    const limit = this.cfg.responseLimitBytes ?? DEFAULT_RESPONSE_LIMIT;
+    if (Number.isFinite(contentLength) && contentLength > limit) {
+      if (mutation) throw outcomeUnknown(rid);
+      throw new CommandFailure("relay_unavailable", "response_too_large", "The relay response exceeded the accepted size.", { requestId: rid });
+    }
+    let bytes;
+    try {
+      bytes = await readBounded(response, limit);
+    } catch (error) {
+      if (mutation) throw outcomeUnknown(rid);
+      throw error;
+    }
+    if (!response.ok) {
+      if (mutation && response.status >= 500) throw outcomeUnknown(rid);
+      const symbol = response.status === 401 ? "authentication_required" : response.status === 403 ? "policy_denied" : "relay_unavailable";
+      const code = response.status === 401 ? "authentication_required" : response.status === 403 ? "policy_denied" : "relay_rejected";
+      throw new CommandFailure(symbol, code, response.status === 401 ? "Sign in with `arp-tui login`." : response.status === 403 ? "The relay policy denied this operation." : "The relay rejected the request.", { operationId: req.operationId, requestId: rid });
+    }
+    if (!(response.headers.get("content-type") ?? "").toLowerCase().startsWith("application/json")) {
+      if (mutation) throw outcomeUnknown(rid);
+      throw new CommandFailure("relay_unavailable", "invalid_content_type", "The relay returned an unsupported response type.", { requestId: rid });
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+      assertJsonDepth(parsed);
+      return req.decode(parsed);
+    } catch (error) {
+      if (mutation) throw outcomeUnknown(rid);
+      if (error instanceof CommandFailure) throw error;
+      throw new CommandFailure("relay_unavailable", "invalid_relay_response", "The relay returned invalid or unexpected JSON.", { requestId: rid });
+    }
+  }
+};
+
 // src/api/types.ts
 function normalizeMember(raw, prev) {
   const id = String(raw?.id ?? raw?.memberId ?? raw?.userId ?? prev?.id ?? "");
   const rawType = raw?.type ?? raw?.memberType;
+  const type = rawType === "bot" ? "bot" : rawType === "human" ? "human" : prev?.type ?? "human";
   const status = raw?.status === "active" || raw?.status === "online" || raw?.isOnline === true ? "online" : raw?.status === "away" ? "away" : raw?.status === "offline" || raw?.isOnline === false ? "offline" : prev?.status ?? "offline";
   return {
     id,
-    type: rawType === "bot" ? "bot" : rawType === "human" ? "human" : prev?.type ?? "human",
-    name: String(raw?.name ?? raw?.displayName ?? raw?.email ?? prev?.name ?? id.slice(0, 8)),
+    type,
+    // Name fallback: a bot's id IS its full agent name — never shorten it.
+    // Only a human's uuid id gets the 8-char short form for display.
+    name: String(raw?.name ?? raw?.displayName ?? raw?.email ?? prev?.name ?? (type === "bot" ? id : id.slice(0, 8))),
     role: raw?.role === "owner" ? "owner" : "member",
     status
   };
@@ -921,6 +1297,58 @@ var RelayRest = class {
     const data = await this.req("GET", "/channels");
     return (data.channels ?? []).map((c) => ({ ...c, members: normalizeMembers(c.members) }));
   }
+  /**
+   * GET /channels?archived=true — the caller's ARCHIVED channels only (the
+   * default listing is active-only; ListChannelsHandler channels.go:274).
+   */
+  async listArchivedChannels() {
+    const data = await this.req("GET", "/channels?archived=true");
+    return (data.channels ?? []).map((c) => ({ ...c, members: normalizeMembers(c.members) }));
+  }
+  /**
+   * POST /channels — create a channel (Braid S3). Body per CreateChannelHandler
+   * (channels.go:66): only {name}; the creator is resolved server-side and
+   * added as owner; visibility defaults to "private".
+   */
+  async createChannel(name) {
+    const data = await this.req("POST", "/channels", { name });
+    const ch = data.channel ?? {};
+    return { ...ch, members: normalizeMembers(ch?.members) };
+  }
+  /** POST /channels/{id}/archive — reversible retire (channels are archive-only; no delete exists). */
+  async archiveChannel(channelId) {
+    await this.req("POST", `/channels/${encodeURIComponent(channelId)}/archive`, {});
+  }
+  /** POST /channels/{id}/unarchive — restore an archived channel (idempotent). */
+  async unarchiveChannel(channelId) {
+    await this.req("POST", `/channels/${encodeURIComponent(channelId)}/unarchive`, {});
+  }
+  /**
+   * POST /channels/{id}/agents/{agentId} — add an already-registered agent to
+   * the channel via the PORTABILITY route (AddExistingAgentToChannelHandler,
+   * agent_add_to_channel.go:35; route router.go:364). agentId is UUID-or-name;
+   * we always send the UUID (unambiguous). This is the ONLY add path that
+   * works for PERSONAL agents: AddMemberHandler's org gate (channels.go:789-797)
+   * COALESCEs a personal agent's NULL org to uuid.Nil → 404 "agent not found".
+   * Owner-only for personal agents; 403 guest_agents_disabled when the channel
+   * org disallows guests. Idempotent; no request body; responds {ok:true}.
+   */
+  async addAgentToChannel(channelId, agentId) {
+    await this.req(
+      "POST",
+      `/channels/${encodeURIComponent(channelId)}/agents/${encodeURIComponent(agentId)}`
+    );
+  }
+  /**
+   * DELETE /channels/{id}/members/{memberId} — memberId is the member row's
+   * member_id: agent name for a bot, user id for a human (channels.go:951,995).
+   */
+  async removeChannelMember(channelId, memberId) {
+    await this.req(
+      "DELETE",
+      `/channels/${encodeURIComponent(channelId)}/members/${encodeURIComponent(memberId)}`
+    );
+  }
   /** GET /channels/{id} */
   async getChannel(channelId) {
     const data = await this.req("GET", `/channels/${encodeURIComponent(channelId)}`);
@@ -966,6 +1394,108 @@ var RelayRest = class {
   async dismissNotification(id) {
     await this.req("POST", `/notifications/${encodeURIComponent(id)}/dismiss`, {});
   }
+  /** POST /agents — mint a personal agent + one-time connect invite (Braid S1 `agent add`) */
+  async createPersonalAgent(name) {
+    return this.req("POST", "/agents", { name });
+  }
+  /** GET /agents/mine — my agents with live presence (Braid S1 `agents`) */
+  async listMyAgents() {
+    const data = await this.req("GET", "/agents/mine");
+    return data.agents ?? [];
+  }
+  /**
+   * POST /agents/{id}/reissue — mint a fresh one-time connect invite for an
+   * existing personal agent (Braid S2 `agent reissue`). Owner-only; 429 when
+   * the relay's register rate limit trips.
+   */
+  async reissueAgent(agentId) {
+    return this.req("POST", `/agents/${encodeURIComponent(agentId)}/reissue`, {});
+  }
+  /** POST /agents/{id}/credential/revoke — revoke the durable key family + close the live WS (Braid S2). */
+  async revokeAgentCredential(agentId) {
+    const data = await this.req(
+      "POST",
+      `/agents/${encodeURIComponent(agentId)}/credential/revoke`,
+      {}
+    );
+    return data.credential ?? {};
+  }
+  /** DELETE /agents/{id} — permanently delete the agent (row, memberships, Clerk machine). */
+  async deleteAgent(agentId) {
+    await this.req("DELETE", `/agents/${encodeURIComponent(agentId)}`);
+  }
+  /**
+   * POST /channels/{id}/agents/invite — mint a PENDING channel-scoped agent
+   * invite (CreateAgentInviteHandler, agent_invite.go:47; route router.go:353,
+   * RequireChannelMembership + RequireOrgAdmin). Body requires {name}
+   * (agent_invite.go:75-77); provisioning happens at redeem. The relay stores
+   * only the secret's SHA-256 — the response is the ONLY copy of the secret.
+   */
+  async createChannelAgentInvite(channelId, name) {
+    return this.req(
+      "POST",
+      `/channels/${encodeURIComponent(channelId)}/agents/invite`,
+      { name }
+    );
+  }
+  /** GET /channels/{id}/agents/invites — the channel's invites, newest first (agent_invites_manage.go:17). */
+  async listChannelAgentInvites(channelId) {
+    const data = await this.req(
+      "GET",
+      `/channels/${encodeURIComponent(channelId)}/agents/invites`
+    );
+    return data.invites ?? [];
+  }
+  /**
+   * DELETE /channels/{id}/agents/invites/{inviteId} — soft-revoke a
+   * channel-scoped invite (agent_invites_manage.go:55). Idempotent 200;
+   * unknown/cross-channel id → 404 "invite not found".
+   */
+  async revokeChannelAgentInvite(channelId, inviteId) {
+    await this.req(
+      "DELETE",
+      `/channels/${encodeURIComponent(channelId)}/agents/invites/${encodeURIComponent(inviteId)}`
+    );
+  }
+  /**
+   * GET /agents/invites — the caller's org's channel-less ORG-kind invites,
+   * newest first, same row shape as the channel listing (org_invites.go:20;
+   * route router.go:236, members.manage-gated → 403 admin_required).
+   */
+  async listOrgAgentInvites() {
+    const data = await this.req("GET", "/agents/invites");
+    return data.invites ?? [];
+  }
+  /** DELETE /agents/invites/{inviteId} — soft-revoke an ORG-kind invite (org_invites.go:65); 404 hides cross-org/channel-kind ids. */
+  async revokeOrgAgentInvite(inviteId) {
+    await this.req("DELETE", `/agents/invites/${encodeURIComponent(inviteId)}`);
+  }
+  /**
+   * POST /channels/{id}/humans/invite — invite a human by email
+   * (InviteHumanHandler, humans_invite.go:26; route router.go:360, org-admin).
+   * Hybrid Clerk+relay: sends a Clerk org invitation and adds a pending user to
+   * the channel; an EXISTING cross-org user joins this channel only, as a guest.
+   */
+  async inviteHumanToChannel(channelId, email) {
+    return this.req(
+      "POST",
+      `/channels/${encodeURIComponent(channelId)}/humans/invite`,
+      { email }
+    );
+  }
+  /** GET /organizations/me — caller's own org id + guest-agent policy (organizations.go:16; 404 when no active org). */
+  async getMyOrganization() {
+    const data = await this.req("GET", "/organizations/me");
+    return data.organization;
+  }
+  /**
+   * PATCH /organizations/{id} {allowGuestAgents} — admin-only, own-org-only
+   * (PatchOrganizationHandler, organizations.go:36-59; route router.go:151,
+   * RequireOrgAdmin → 403 admin_required; cross-org id → 404).
+   */
+  async patchOrganization(orgId, patch) {
+    await this.req("PATCH", `/organizations/${encodeURIComponent(orgId)}`, patch);
+  }
 };
 
 // src/state/activityFold.ts
@@ -1037,10 +1567,10 @@ function foldActivityEvents(events) {
 
 // src/state/priority.ts
 function channelPriority(cid, p) {
-  const level = p.attention[cid]?.highestLevel;
-  if (level === "critical") return 0;
-  if (level === "action_required") return 1;
-  if (level === "info") return 2;
+  const level2 = p.attention[cid]?.highestLevel;
+  if (level2 === "critical") return 0;
+  if (level2 === "action_required") return 1;
+  if (level2 === "info") return 2;
   if ((p.unread[cid] ?? 0) > 0) return 3;
   return 4;
 }
@@ -1342,6 +1872,10 @@ function createStore(opts) {
     unread: { ...config.unread ?? {} },
     unreadCapNotice: null,
     attention: {},
+    channelAttention: [],
+    attentionSelected: 0,
+    attentionDraft: "",
+    attentionBusy: false,
     notifications: [],
     notifSelected: 0,
     activityByTurn: {},
@@ -1498,6 +2032,9 @@ function createStore(opts) {
   }
   const rest = new RelayRest({ relayUrl, getToken });
   const ws = new RelayWs({ relayUrl, getToken });
+  const attentionApi = () => opts.attentionApi ?? new AttentionMutations(new LifecycleTransport({ relayUrl, getToken }));
+  let pendingAttentionLevel = null;
+  let pendingAttentionAck = null;
   function pushDivider(label) {
     const id = `divider-${++dividerCounter}`;
     seen.add(id);
@@ -1595,6 +2132,141 @@ function createStore(opts) {
     const next = Math.max(0, Math.min(state.notifSelected + delta, len - 1));
     set({ notifSelected: next });
   }
+  async function refreshChannelAttention() {
+    const channelId = state.activeChannelId;
+    if (!channelId) return;
+    try {
+      const items = await attentionApi().listChannel(channelId);
+      if (state.activeChannelId !== channelId) return;
+      setThrottled({
+        channelAttention: items,
+        attentionSelected: Math.max(0, Math.min(state.attentionSelected, items.length - 1))
+      });
+    } catch (error) {
+      if (error instanceof CommandFailure && state.mode.startsWith("attention")) {
+        set({ error: `${error.stableCode}: ${error.message}` });
+      }
+    }
+  }
+  function finishAttentionMutation(error) {
+    pendingAttentionLevel = null;
+    pendingAttentionAck = null;
+    set({
+      mode: "attention",
+      attentionDraft: "",
+      attentionBusy: false,
+      error: error instanceof CommandFailure ? `${error.stableCode}: ${error.message}` : error ? "attention operation failed safely" : null
+    });
+    void refreshChannelAttention();
+    void pollAttention();
+  }
+  async function performAttentionRaise(level2, reason) {
+    const channelId = state.activeChannelId;
+    if (!channelId || state.attentionBusy) return;
+    set({ mode: "attention", attentionDraft: "", attentionBusy: true, error: null });
+    const operationId = (opts.newOperationId ?? randomUUID)();
+    try {
+      const api = attentionApi();
+      const before = await api.listChannel(channelId);
+      const previousCount = before.find((item) => item.level === level2)?.count ?? 0;
+      try {
+        await api.raise({ channelId, level: level2, reason, operationId });
+      } catch (error) {
+        if (!(error instanceof OutcomeUnknown)) throw error;
+        const current = (await api.listChannel(channelId)).find((item) => item.level === level2);
+        if (!current || current.reason !== reason || current.count <= previousCount) throw error;
+      }
+      finishAttentionMutation();
+    } catch (error) {
+      finishAttentionMutation(error);
+    }
+  }
+  async function performAttentionAck(scope) {
+    const channelId = state.activeChannelId;
+    if (!channelId || state.attentionBusy) return;
+    set({ mode: "attention", attentionDraft: "", attentionBusy: true, error: null });
+    const operationId = (opts.newOperationId ?? randomUUID)();
+    try {
+      const api = attentionApi();
+      try {
+        await api.ack({ channelId, ...scope === "all" ? {} : { level: scope }, operationId });
+      } catch (error) {
+        if (!(error instanceof OutcomeUnknown)) throw error;
+        const current = await api.listChannel(channelId);
+        const reconciled = scope === "all" ? current.length === 0 : !current.some((item) => item.level === scope);
+        if (!reconciled) throw error;
+      }
+      finishAttentionMutation();
+    } catch (error) {
+      finishAttentionMutation(error);
+    }
+  }
+  function openAttention() {
+    if (!state.activeChannelId || state.attentionBusy) return;
+    set({ mode: "attention", attentionDraft: "", attentionSelected: 0, error: null });
+    void refreshChannelAttention();
+  }
+  function closeAttention() {
+    if (state.attentionBusy) return;
+    pendingAttentionLevel = null;
+    pendingAttentionAck = null;
+    set({
+      mode: state.mode === "attention" ? "normal" : "attention",
+      attentionDraft: "",
+      error: null
+    });
+  }
+  function moveAttentionSelection(delta) {
+    if (state.channelAttention.length === 0 || state.attentionBusy) return;
+    set({ attentionSelected: Math.max(0, Math.min(state.attentionSelected + delta, state.channelAttention.length - 1)) });
+  }
+  function beginAttentionRaise() {
+    if (state.attentionBusy) return;
+    pendingAttentionLevel = null;
+    pendingAttentionAck = null;
+    set({ mode: "attention_level", attentionDraft: "", error: null });
+  }
+  function beginAttentionAck(all) {
+    if (state.attentionBusy) return;
+    if (all) pendingAttentionAck = "all";
+    else pendingAttentionAck = state.channelAttention[state.attentionSelected]?.level ?? null;
+    if (!pendingAttentionAck) return;
+    set({ mode: "attention_confirm", attentionDraft: "", error: null });
+  }
+  function setAttentionDraft(value) {
+    const max = state.mode === "attention_level" ? 32 : state.mode === "attention_confirm" ? 36 : 1024;
+    if (Buffer.byteLength(value, "utf8") <= max) set({ attentionDraft: value });
+  }
+  function submitAttentionInput() {
+    if (state.attentionBusy) return;
+    if (state.mode === "attention_level") {
+      const value = state.attentionDraft.trim();
+      if (!ATTENTION_LEVELS.has(value)) {
+        set({ error: "level must be info, action_required, or critical" });
+        return;
+      }
+      pendingAttentionLevel = value;
+      set({ mode: "attention_reason", attentionDraft: "", error: null });
+      return;
+    }
+    if (state.mode === "attention_reason") {
+      if (!pendingAttentionLevel) return;
+      try {
+        const reason = normalizeReason(state.attentionDraft);
+        void performAttentionRaise(pendingAttentionLevel, reason);
+      } catch (error) {
+        if (error instanceof CommandFailure) set({ error: `${error.stableCode}: ${error.message}` });
+      }
+      return;
+    }
+    if (state.mode === "attention_confirm") {
+      if (state.attentionDraft !== state.activeChannelId) {
+        set({ error: "confirmation did not match the channel UUID" });
+        return;
+      }
+      if (pendingAttentionAck) void performAttentionAck(pendingAttentionAck);
+    }
+  }
   function seedPresence(members) {
     const presence = {};
     for (const m of members) presence[m.id] = m.status === "online" ? "active" : m.status;
@@ -1811,6 +2483,16 @@ function createStore(opts) {
         pushDivider("channel archived");
         return;
       }
+      case "channel.attention.raised":
+      case "channel.attention.updated":
+      case "channel.attention.cleared":
+      case "channel.attention.acked": {
+        void pollAttention();
+        if (frame.channelId === state.activeChannelId && state.mode.startsWith("attention")) {
+          void refreshChannelAttention();
+        }
+        return;
+      }
       case "activity_event": {
         if (frame.channelId !== state.activeChannelId) return;
         if (!frame.turnId || !frame.toolCallId) return;
@@ -2093,6 +2775,13 @@ function createStore(opts) {
     dismissNotification: (id) => void dismissNotification(id),
     markAllNotificationsRead: () => void markAllNotificationsRead(),
     moveNotifSelection,
+    openAttention,
+    closeAttention,
+    moveAttentionSelection,
+    beginAttentionRaise,
+    beginAttentionAck,
+    setAttentionDraft,
+    submitAttentionInput,
     jumpNextActive: () => {
       const s = state;
       const target = nextActiveChannel(s.channels, s.activeChannelId, { attention: s.attention, unread: s.unread });
@@ -2105,22 +2794,6 @@ function createStore(opts) {
 
 // src/ui/ActivityLine.tsx
 import { Text } from "ink";
-
-// src/util/sanitize.ts
-var ESCAPE_SEQ = (
-  // eslint-disable-next-line no-control-regex
-  /\x1b(?:\[[0-?]*[ -/]*[@-~]|\][\s\S]*?(?:\x07|\x1b\\)|[PX^_][\s\S]*?\x1b\\|[@-Z\\-_])/g
-);
-var CONTROL_CHARS = /[\x00-\x08\x0b-\x1f\x7f]/g;
-function sanitizeForTty(input) {
-  return input.replace(ESCAPE_SEQ, "").replace(CONTROL_CHARS, "");
-}
-function sanitizeLabel(input, max = 40) {
-  const clean = sanitizeForTty(input);
-  return clean.length > max ? clean.slice(0, max - 1) + "\u2026" : clean;
-}
-
-// src/ui/ActivityLine.tsx
 import { jsx, jsxs } from "react/jsx-runtime";
 var MAX_SHOWN = 3;
 function ActivityLine({ activities }) {
@@ -2212,7 +2885,7 @@ function ActivitySurface(props) {
         pinned && call.locations && call.locations.length > 0 && /* @__PURE__ */ jsx2(Box, { flexDirection: "column", paddingLeft: 2, children: call.locations.map((loc, i) => /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
           sanitizeLabel(loc.path, 60),
           loc.line != null ? `:${loc.line}` : ""
-        ] }, i)) })
+        ] }, `${loc.path}:${loc.line ?? ""}#${i}`)) })
       ] }, call.toolCallId))
     ] }),
     plan.length > 0 && /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
@@ -2221,15 +2894,71 @@ function ActivitySurface(props) {
         planGlyph(entry.status),
         " ",
         sanitizeForTty(entry.content)
-      ] }, i))
+      ] }, `${entry.content}#${i}`))
     ] }),
     /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: pinHint })
   ] });
 }
 
-// src/ui/ChannelSwitcher.tsx
+// src/ui/AttentionPanel.tsx
 import { Box as Box2, Text as Text3 } from "ink";
 import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var LEVEL_COLOR = {
+  info: "blue",
+  action_required: "yellow",
+  critical: "red"
+};
+function AttentionPanel({
+  channelId,
+  items,
+  selected,
+  mode,
+  draft,
+  busy
+}) {
+  const prompt = mode === "attention_level" ? "level (info | action_required | critical)" : mode === "attention_reason" ? "reason" : mode === "attention_confirm" ? `type ${channelId} to confirm` : null;
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+      "ATTENTION  channel:",
+      sanitizeForTty(channelId)
+    ] }),
+    items.length === 0 ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "no active attention" }) : items.map((item, index) => /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        /* @__PURE__ */ jsxs3(Text3, { color: index === selected ? "cyan" : void 0, children: [
+          index === selected ? ">" : " ",
+          " "
+        ] }),
+        /* @__PURE__ */ jsx3(Text3, { bold: true, color: LEVEL_COLOR[item.level], children: item.level }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          "  count:",
+          item.count,
+          "  ",
+          item.raisedByType ?? "unknown",
+          ":",
+          sanitizeForTty(item.raisedBy ?? "unknown")
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { wrap: "wrap", children: [
+        "  ",
+        sanitizeForTty(item.reason)
+      ] }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "  updated ",
+        sanitizeForTty(item.updatedAt)
+      ] })
+    ] }, item.id)),
+    prompt ? /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+      prompt,
+      ": ",
+      sanitizeForTty(draft),
+      "\u258C"
+    ] }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: busy ? "working\u2026" : "j/k select \xB7 r raise \xB7 x ack selected \xB7 X ack all \xB7 Esc close" })
+  ] });
+}
+
+// src/ui/ChannelSwitcher.tsx
+import { Box as Box3, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
 function channelLabel(ch) {
   return `${channelSigil(ch.kind)}${sanitizeLabel(ch.name)}`;
 }
@@ -2244,7 +2973,7 @@ function ChannelBadge({
   if (att) {
     const color = att.highestLevel === "critical" ? "red" : att.highestLevel === "action_required" ? "yellow" : "cyan";
     const sigil = att.highestLevel === "critical" ? "!" : att.highestLevel === "action_required" ? "\u25B2" : "\u2022";
-    return /* @__PURE__ */ jsxs3(Text3, { color, children: [
+    return /* @__PURE__ */ jsxs4(Text4, { color, children: [
       " ",
       "[",
       sigil,
@@ -2252,11 +2981,11 @@ function ChannelBadge({
       "]"
     ] });
   }
-  const count = unread[channelId] ?? 0;
-  if (count > 0) {
-    return /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+  const count2 = unread[channelId] ?? 0;
+  if (count2 > 0) {
+    return /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
       " (",
-      count,
+      count2,
       ")"
     ] });
   }
@@ -2273,11 +3002,11 @@ function ChannelSwitcher({
   const sorted = sortChannelsByPriority(filtered, { attention, unread });
   const visible = sorted.slice(0, 9);
   const hidden = sorted.length - visible.length;
-  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs4(Text4, { bold: true, children: [
       "channels",
       " ",
-      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
         "(",
         sorted.length,
         "/",
@@ -2285,23 +3014,23 @@ function ChannelSwitcher({
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs3(Text3, { children: [
-      /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "filter: " }),
-      /* @__PURE__ */ jsx3(Text3, { children: sanitizeLabel(filter, 40) }),
-      /* @__PURE__ */ jsx3(Text3, { inverse: true, children: " " })
+    /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "filter: " }),
+      /* @__PURE__ */ jsx4(Text4, { children: sanitizeLabel(filter, 40) }),
+      /* @__PURE__ */ jsx4(Text4, { inverse: true, children: " " })
     ] }),
-    visible.map((ch, i) => /* @__PURE__ */ jsxs3(Text3, { children: [
-      /* @__PURE__ */ jsxs3(Text3, { color: "cyan", children: [
+    visible.map((ch, i) => /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "cyan", children: [
         i + 1,
         " "
       ] }),
-      /* @__PURE__ */ jsx3(Text3, { bold: ch.id === activeChannelId, children: channelLabel(ch) }),
-      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      /* @__PURE__ */ jsx4(Text4, { bold: ch.id === activeChannelId, children: channelLabel(ch) }),
+      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
         " \xB7 ",
         ch.members.length,
         " members"
       ] }),
-      /* @__PURE__ */ jsx3(
+      /* @__PURE__ */ jsx4(
         ChannelBadge,
         {
           channelId: ch.id,
@@ -2311,36 +3040,36 @@ function ChannelSwitcher({
         }
       )
     ] }, ch.id)),
-    hidden > 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    hidden > 0 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
       "\u2026",
       hidden,
       " more \u2014 keep typing to narrow"
     ] }) : null,
-    sorted.length === 0 ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+    sorted.length === 0 ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
       'no channels match "',
       sanitizeLabel(filter, 20),
       '"'
     ] }) : null,
-    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: filter.length === 0 ? "type to filter \xB7 1\u20139 quick-select \xB7 n jump \xB7 Esc cancel" : "keep typing to narrow \xB7 Enter opens top match \xB7 Esc cancel" })
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: filter.length === 0 ? "type to filter \xB7 1\u20139 quick-select \xB7 n jump \xB7 Esc cancel" : "keep typing to narrow \xB7 Enter opens top match \xB7 Esc cancel" })
   ] });
 }
 
 // src/ui/Composer.tsx
-import { Box as Box3, Text as Text4 } from "ink";
-import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+import { Box as Box4, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
 function Composer({ draft, focused }) {
   const width = Math.max((process.stdout.columns ?? 80) - 8, 20);
   const visible = draft.length > width ? "\u2026" + draft.slice(-(width - 1)) : draft;
-  return /* @__PURE__ */ jsx4(Box3, { borderStyle: "round", borderColor: focused ? "cyan" : "gray", paddingX: 1, width: "100%", children: /* @__PURE__ */ jsxs4(Text4, { wrap: "truncate", children: [
-    /* @__PURE__ */ jsx4(Text4, { color: focused ? "cyan" : "gray", children: "> " }),
-    draft.length === 0 && !focused ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "i to compose" }) : /* @__PURE__ */ jsx4(Text4, { children: visible }),
-    focused ? /* @__PURE__ */ jsx4(Text4, { inverse: true, children: " " }) : null
+  return /* @__PURE__ */ jsx5(Box4, { borderStyle: "round", borderColor: focused ? "cyan" : "gray", paddingX: 1, width: "100%", children: /* @__PURE__ */ jsxs5(Text5, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsx5(Text5, { color: focused ? "cyan" : "gray", children: "> " }),
+    draft.length === 0 && !focused ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "i to compose" }) : /* @__PURE__ */ jsx5(Text5, { children: visible }),
+    focused ? /* @__PURE__ */ jsx5(Text5, { inverse: true, children: " " }) : null
   ] }) });
 }
 
 // src/ui/Header.tsx
-import { Box as Box4, Text as Text5 } from "ink";
-import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
 var STATUS_DOT = {
   online: { glyph: "\u25CF", color: "green" },
   away: { glyph: "\u25D0", color: "yellow" },
@@ -2357,32 +3086,32 @@ function Header({
   members,
   presence
 }) {
-  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs5(Box4, { justifyContent: "space-between", children: [
-      /* @__PURE__ */ jsxs5(Text5, { children: [
-        /* @__PURE__ */ jsx5(Text5, { color: "cyan", bold: true, children: "arp-tui" }),
-        /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: " \u25B8 " }),
-        /* @__PURE__ */ jsxs5(Text5, { bold: true, children: [
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box5, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs6(Text6, { children: [
+        /* @__PURE__ */ jsx6(Text6, { color: "cyan", bold: true, children: "arp-tui" }),
+        /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: " \u25B8 " }),
+        /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
           channelSigil(channelKind),
           sanitizeLabel(channelName)
         ] })
       ] }),
-      /* @__PURE__ */ jsx5(Text5, { children: members.map((m) => {
+      /* @__PURE__ */ jsx6(Text6, { children: members.map((m) => {
         const dot = STATUS_DOT[effectiveStatus(m, presence)];
-        return /* @__PURE__ */ jsxs5(Text5, { children: [
-          /* @__PURE__ */ jsxs5(Text5, { color: dot.color, children: [
+        return /* @__PURE__ */ jsxs6(Text6, { children: [
+          /* @__PURE__ */ jsxs6(Text6, { color: dot.color, children: [
             dot.glyph,
             " "
           ] }),
-          /* @__PURE__ */ jsxs5(Text5, { dimColor: effectiveStatus(m, presence) === "offline", children: [
+          /* @__PURE__ */ jsxs6(Text6, { dimColor: effectiveStatus(m, presence) === "offline", children: [
             m.type === "bot" ? "\u2699" : "",
             sanitizeLabel(m.name, 20)
           ] }),
-          /* @__PURE__ */ jsx5(Text5, { children: "  " })
+          /* @__PURE__ */ jsx6(Text6, { children: "  " })
         ] }, m.id);
       }) })
     ] }),
-    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500".repeat(Math.min(process.stdout.columns ?? 80, 100)) })
+    /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "\u2500".repeat(Math.min(process.stdout.columns ?? 80, 100)) })
   ] });
 }
 
@@ -2390,8 +3119,8 @@ function Header({
 import { Static } from "ink";
 
 // src/ui/MessageRow.tsx
-import { Box as Box5, Text as Text6 } from "ink";
-import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 function hhmm(rfc3339) {
   const d = new Date(rfc3339);
   return isNaN(d.getTime()) ? "--:--" : `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
@@ -2404,7 +3133,7 @@ function TokenChip({ message }) {
   if (message.messageType !== "agent" || !message.tokensUsed) return null;
   const parts = [`${formatTokens(message.tokensUsed)} tok`];
   if (message.model) parts.push(sanitizeLabel(message.model, 16));
-  return /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
     message.verified ? "\u2713 " : "",
     parts.join(" \xB7 ")
   ] });
@@ -2414,41 +3143,41 @@ function MessageRow({ message }) {
   const isSystem = message.messageType === "system";
   const name = sanitizeLabel(message.agentName, 20);
   if (isSystem) {
-    return /* @__PURE__ */ jsx6(Box5, { children: /* @__PURE__ */ jsxs6(Text6, { dimColor: true, italic: true, children: [
+    return /* @__PURE__ */ jsx7(Box6, { children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, italic: true, children: [
       "       ",
       "\u2500\u2500 ",
       sanitizeForTty(message.content),
       " \u2500\u2500"
     ] }) });
   }
-  return /* @__PURE__ */ jsxs6(Box5, { justifyContent: "space-between", gap: 2, children: [
-    /* @__PURE__ */ jsx6(Box5, { flexShrink: 1, children: /* @__PURE__ */ jsxs6(Text6, { children: [
-      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs7(Box6, { justifyContent: "space-between", gap: 2, children: [
+    /* @__PURE__ */ jsx7(Box6, { flexShrink: 1, children: /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
         hhmm(message.createdAt),
         " "
       ] }),
-      /* @__PURE__ */ jsxs6(Text6, { color: isBot ? "magenta" : "cyan", bold: !isBot, children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: isBot ? "magenta" : "cyan", bold: !isBot, children: [
         isBot ? "\u2699" : "",
         name.padEnd(12)
       ] }),
-      /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsxs7(Text7, { children: [
         " ",
         sanitizeForTty(message.content)
       ] })
     ] }) }),
-    /* @__PURE__ */ jsx6(Box5, { flexShrink: 0, children: /* @__PURE__ */ jsx6(TokenChip, { message }) })
+    /* @__PURE__ */ jsx7(Box6, { flexShrink: 0, children: /* @__PURE__ */ jsx7(TokenChip, { message }) })
   ] });
 }
 
 // src/ui/MessageList.tsx
-import { jsx as jsx7 } from "react/jsx-runtime";
+import { jsx as jsx8 } from "react/jsx-runtime";
 function MessageList({ messages }) {
-  return /* @__PURE__ */ jsx7(Static, { items: messages, children: (m) => /* @__PURE__ */ jsx7(MessageRow, { message: m }, m.id) });
+  return /* @__PURE__ */ jsx8(Static, { items: messages, children: (m) => /* @__PURE__ */ jsx8(MessageRow, { message: m }, m.id) });
 }
 
 // src/ui/NotificationsPanel.tsx
-import { Box as Box6, Text as Text7 } from "ink";
-import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Box as Box7, Text as Text8 } from "ink";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
 function relativeAge(createdAt) {
   const ms = Date.now() - new Date(createdAt).getTime();
   if (!Number.isFinite(ms) || ms < 0) return "\u2014";
@@ -2466,11 +3195,11 @@ function NotificationsPanel({
   notifSelected
 }) {
   const unreadCount = notifications.filter((n) => !n.readAt).length;
-  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+  return /* @__PURE__ */ jsxs8(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs8(Text8, { bold: true, children: [
       "alerts",
       " ",
-      /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
         "(",
         unreadCount,
         " unread \xB7 ",
@@ -2478,38 +3207,42 @@ function NotificationsPanel({
         " total)"
       ] })
     ] }),
-    notifications.length === 0 ? /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "no notifications" }) : notifications.map((n, i) => {
+    notifications.length === 0 ? /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "no notifications" }) : notifications.map((n, i) => {
       const isSelected = i === notifSelected;
       const isUnread = n.readAt === null;
       const type = sanitizeLabel(n.type, 20);
       const ref = shortRef(sanitizeForTty(n.entityRef));
       const age = relativeAge(n.createdAt);
-      return /* @__PURE__ */ jsxs7(Text7, { inverse: isSelected, children: [
-        isUnread ? /* @__PURE__ */ jsx8(Text7, { color: "yellow", children: "\u2022 " }) : /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "  " }),
-        /* @__PURE__ */ jsx8(Text7, { bold: isSelected, children: type }),
-        /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+      return /* @__PURE__ */ jsxs8(Text8, { inverse: isSelected, children: [
+        isUnread ? /* @__PURE__ */ jsx9(Text8, { color: "yellow", children: "\u2022 " }) : /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "  " }),
+        /* @__PURE__ */ jsx9(Text8, { bold: isSelected, children: type }),
+        /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
           " ",
           ref
         ] }),
-        /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+        /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
           " ",
           age
         ] })
       ] }, n.id);
     }),
-    /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "J/K move \xB7 d dismiss \xB7 a mark all read \xB7 Esc close" })
+    /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "J/K move \xB7 d dismiss \xB7 a mark all read \xB7 Esc close" })
   ] });
 }
 
 // src/ui/StatusBar.tsx
-import { Text as Text8 } from "ink";
-import { Fragment, jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+import { Text as Text9 } from "ink";
+import { Fragment, jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 var MODE_LABEL = {
   normal: "NORMAL",
   insert: "INSERT",
   switcher: "CHANNELS",
   token: "TOKEN",
-  notifications: "ALERTS"
+  notifications: "ALERTS",
+  attention: "ATTENTION",
+  attention_level: "ATTENTION LEVEL",
+  attention_reason: "ATTENTION REASON",
+  attention_confirm: "CONFIRM ATTENTION"
 };
 function ageLabel(obtainedAt) {
   if (!obtainedAt) return "\u2014";
@@ -2560,41 +3293,41 @@ function StatusBar({
       color: stale ? "yellow" : "green"
     };
   }
-  return /* @__PURE__ */ jsxs8(Text8, { children: [
-    /* @__PURE__ */ jsxs8(Text8, { bold: true, color: mode === "insert" ? "cyan" : mode === "token" ? "yellow" : "white", children: [
+  return /* @__PURE__ */ jsxs9(Text9, { children: [
+    /* @__PURE__ */ jsxs9(Text9, { bold: true, color: mode === "insert" ? "cyan" : mode === "token" ? "yellow" : "white", children: [
       " ",
       MODE_LABEL[mode],
       " "
     ] }),
-    /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: "\u2502 " }),
-    /* @__PURE__ */ jsx9(Text8, { color: connColor, children: connectionLabel(connection, reconnectAt, reconnectAttempt) }),
-    /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " \u2502 " }),
-    /* @__PURE__ */ jsx9(Text8, { color: tokenSeg.color, children: tokenSeg.text }),
-    /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+    /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "\u2502 " }),
+    /* @__PURE__ */ jsx10(Text9, { color: connColor, children: connectionLabel(connection, reconnectAt, reconnectAttempt) }),
+    /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: " \u2502 " }),
+    /* @__PURE__ */ jsx10(Text9, { color: tokenSeg.color, children: tokenSeg.text }),
+    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
       " \u2502 seq ",
       lastSeq ?? "\u2014"
     ] }),
-    notifCount > 0 ? /* @__PURE__ */ jsxs8(Text8, { color: "yellow", children: [
+    notifCount > 0 ? /* @__PURE__ */ jsxs9(Text9, { color: "yellow", children: [
       " \u2502 alerts:",
       notifCount
     ] }) : null,
     error ? (
       // BL-222: an error replaces the full hint line but must never strand
       // the user — keep the exit hint visible alongside it
-      /* @__PURE__ */ jsxs8(Fragment, { children: [
-        /* @__PURE__ */ jsxs8(Text8, { color: "red", children: [
+      /* @__PURE__ */ jsxs9(Fragment, { children: [
+        /* @__PURE__ */ jsxs9(Text9, { color: "red", children: [
           " \u2502 ",
           sanitizeForTty(error)
         ] }),
-        /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " \u2502 q quit" })
+        /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: " \u2502 q quit" })
       ] })
-    ) : /* @__PURE__ */ jsx9(Text8, { dimColor: true, children: " \u2502 c channels \xB7 a alerts \xB7 n next \xB7 v watch \xB7 i compose \xB7 r reconnect \xB7 Esc normal \xB7 q quit" })
+    ) : /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: " \u2502 c channels \xB7 a alerts \xB7 t attention \xB7 n next \xB7 v watch \xB7 i compose \xB7 r reconnect \xB7 Esc normal \xB7 q quit" })
   ] });
 }
 
 // src/ui/TokenPrompt.tsx
-import { Box as Box7, Text as Text9 } from "ink";
-import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Box as Box8, Text as Text10 } from "ink";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 function TokenPrompt({
   value,
   reason,
@@ -2602,26 +3335,26 @@ function TokenPrompt({
   jwtTemplate
 }) {
   const masked = value.length === 0 ? "" : value.length <= 16 ? value : `${value.slice(0, 12)}\u2026 (${value.length} chars)`;
-  return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx10(Text9, { bold: true, color: "yellow", children: "token needed" }),
-    reason ? /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: sanitizeForTty(reason) }) : null,
-    /* @__PURE__ */ jsxs9(Text9, { dimColor: true, children: [
+  return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx11(Text10, { bold: true, color: "yellow", children: "token needed" }),
+    reason ? /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: sanitizeForTty(reason) }) : null,
+    /* @__PURE__ */ jsxs10(Text10, { dimColor: true, children: [
       "mint one: open ",
       webUrl,
       " logged in, browser console:"
     ] }),
-    /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: `  await window.Clerk.session.getToken({template:'${jwtTemplate}'})` }),
-    /* @__PURE__ */ jsxs9(Text9, { children: [
-      /* @__PURE__ */ jsx10(Text9, { color: "yellow", children: "> " }),
-      /* @__PURE__ */ jsx10(Text9, { children: masked }),
-      /* @__PURE__ */ jsx10(Text9, { inverse: true, children: " " })
+    /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: `  await window.Clerk.session.getToken({template:'${jwtTemplate}'})` }),
+    /* @__PURE__ */ jsxs10(Text10, { children: [
+      /* @__PURE__ */ jsx11(Text10, { color: "yellow", children: "> " }),
+      /* @__PURE__ */ jsx11(Text10, { children: masked }),
+      /* @__PURE__ */ jsx11(Text10, { inverse: true, children: " " })
     ] }),
-    /* @__PURE__ */ jsx10(Text9, { dimColor: true, children: "paste, then Enter \xB7 Ctrl+C quits" })
+    /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "paste, then Enter \xB7 Ctrl+C quits" })
   ] });
 }
 
 // src/app.tsx
-import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
 var ACTIVITY_SETTLE_MS2 = 4e3;
 function cleanInput(input) {
   return input.replace(/\r\n|[\r\n]/g, " ").replace(/[\x00-\x1f\x7f]/g, "");
@@ -2668,6 +3401,22 @@ function App({ store: store2 }) {
         } else if (input === "a") store2.markAllNotificationsRead();
         return;
       }
+      if (s.mode.startsWith("attention")) {
+        if (s.mode !== "attention") {
+          if (key.escape) store2.closeAttention();
+          else if (key.return) store2.submitAttentionInput();
+          else if (key.backspace || key.delete) store2.setAttentionDraft(s.attentionDraft.slice(0, -1));
+          else if (input) store2.setAttentionDraft(s.attentionDraft + cleanInput(input));
+          return;
+        }
+        if (key.escape) store2.closeAttention();
+        else if (input === "j" || key.downArrow) store2.moveAttentionSelection(1);
+        else if (input === "k" || key.upArrow) store2.moveAttentionSelection(-1);
+        else if (input === "r") store2.beginAttentionRaise();
+        else if (input === "x") store2.beginAttentionAck(false);
+        else if (input === "X") store2.beginAttentionAck(true);
+        return;
+      }
       if (s.mode === "switcher") {
         const filtered = filterChannels(s.channels, s.switcherFilter);
         const sorted = sortChannelsByPriority(filtered, { attention: s.attention, unread: s.unread });
@@ -2691,6 +3440,7 @@ function App({ store: store2 }) {
         exit();
       } else if (input === "c") store2.setMode("switcher");
       else if (input === "a") store2.setMode("notifications");
+      else if (input === "t") store2.openAttention();
       else if (input === "i" || key.return) store2.setMode("insert");
       else if (input === "r") store2.reconnectNow();
       else if (input === "n") store2.jumpNextActive();
@@ -2708,8 +3458,8 @@ function App({ store: store2 }) {
   const activityLive = activityRows.some((r) => r.status === "pending" || r.status === "in_progress") || activityPlan.some((e) => e.status !== "completed");
   const activityWithinSettle = state.activityIdleSince !== null && Date.now() - state.activityIdleSince < ACTIVITY_SETTLE_MS2;
   const activityVisible = state.activityPinned || activityLive || activityWithinSettle;
-  return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx11(
+  return /* @__PURE__ */ jsxs11(Box9, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx12(
       Header,
       {
         channelName: activeChannel?.name ?? "(connecting\u2026)",
@@ -2718,9 +3468,9 @@ function App({ store: store2 }) {
         presence: state.presence
       }
     ),
-    /* @__PURE__ */ jsx11(MessageList, { messages: state.messages }),
-    /* @__PURE__ */ jsx11(ActivitySurface, { toolCalls: activityRows, plan: activityPlan, visible: activityVisible, pinned: state.activityPinned }),
-    state.mode === "switcher" ? /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(MessageList, { messages: state.messages }),
+    /* @__PURE__ */ jsx12(ActivitySurface, { toolCalls: activityRows, plan: activityPlan, visible: activityVisible, pinned: state.activityPinned }),
+    state.mode === "switcher" ? /* @__PURE__ */ jsx12(
       ChannelSwitcher,
       {
         channels: state.channels,
@@ -2730,14 +3480,25 @@ function App({ store: store2 }) {
         unread: state.unread
       }
     ) : null,
-    state.mode === "notifications" ? /* @__PURE__ */ jsx11(
+    state.mode === "notifications" ? /* @__PURE__ */ jsx12(
       NotificationsPanel,
       {
         notifications: state.notifications,
         notifSelected: state.notifSelected
       }
     ) : null,
-    state.mode === "token" ? /* @__PURE__ */ jsx11(
+    state.mode.startsWith("attention") && state.activeChannelId ? /* @__PURE__ */ jsx12(
+      AttentionPanel,
+      {
+        channelId: state.activeChannelId,
+        items: state.channelAttention,
+        selected: state.attentionSelected,
+        mode: state.mode,
+        draft: state.attentionDraft,
+        busy: state.attentionBusy
+      }
+    ) : null,
+    state.mode === "token" ? /* @__PURE__ */ jsx12(
       TokenPrompt,
       {
         value: state.tokenPrompt,
@@ -2746,9 +3507,9 @@ function App({ store: store2 }) {
         jwtTemplate: store2.instance.clerkJwtTemplate
       }
     ) : null,
-    /* @__PURE__ */ jsx11(ActivityLine, { activities: state.activities }),
-    /* @__PURE__ */ jsx11(Composer, { draft: state.draft, focused: state.mode === "insert" }),
-    /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(ActivityLine, { activities: state.activities }),
+    /* @__PURE__ */ jsx12(Composer, { draft: state.draft, focused: state.mode === "insert" }),
+    /* @__PURE__ */ jsx12(
       StatusBar,
       {
         mode: state.mode,
@@ -2764,7 +3525,7 @@ function App({ store: store2 }) {
         error: state.error
       }
     ),
-    !interactive ? /* @__PURE__ */ jsx11(Text10, { dimColor: true, children: "(non-interactive terminal: keys disabled \u2014 tail is read-only here)" }) : null
+    !interactive ? /* @__PURE__ */ jsx12(Text11, { dimColor: true, children: "(non-interactive terminal: keys disabled \u2014 tail is read-only here)" }) : null
   ] });
 }
 
@@ -2847,8 +3608,1144 @@ unknown profile command "${args2.sub}".`);
   }
 }
 
+// src/api/bridgeProcess.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_BRIDGE_CMD = "npx -y @snowyroad/braid";
+var ENROLL_TIMEOUT_MS = 12e4;
+var STDERR_TAIL_CHARS = 600;
+function resolveBridgeCmd(flag, env = process.env) {
+  return flag ?? env["ARP_TUI_BRIDGE_CMD"] ?? DEFAULT_BRIDGE_CMD;
+}
+function splitCmd(cmd) {
+  return cmd.trim().split(/\s+/).filter(Boolean);
+}
+function enrollArgv(bridgeCmd) {
+  return [...splitCmd(bridgeCmd), "enroll", "--invite-stdin", "--json"];
+}
+function startArgv(bridgeCmd, name, provider) {
+  return [...splitCmd(bridgeCmd), "start", name, ...provider ? ["--provider", provider] : []];
+}
+function enrollAgent(opts) {
+  const [cmd, ...argv] = enrollArgv(opts.bridgeCmd);
+  if (!cmd) {
+    return Promise.resolve({ ok: false, exitCode: null, message: "empty bridge command", stderrTail: "" });
+  }
+  return new Promise((resolve) => {
+    const child = spawn2(cmd, argv, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeoutMs = opts.timeoutMs ?? ENROLL_TIMEOUT_MS;
+    const finish = (r) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(r);
+    };
+    const timer = setTimeout(() => {
+      finish({
+        ok: false,
+        exitCode: null,
+        message: `bridge enrollment timed out after ${Math.round(timeoutMs / 1e3)}s`,
+        stderrTail: tail(stderr)
+      });
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.on("error", (err) => {
+      finish({
+        ok: false,
+        exitCode: null,
+        message: `could not run the bridge (${cmd}): ${sanitizeForTty(err.message)}`,
+        stderrTail: ""
+      });
+    });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (d) => stdout += d);
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (d) => stderr += d);
+    child.stdin.on("error", () => {
+    });
+    child.stdin.write(opts.connectBlob);
+    child.stdin.end();
+    child.on("close", (code) => {
+      if (code !== 0) {
+        finish({
+          ok: false,
+          exitCode: code,
+          message: `bridge enroll exited ${code ?? "on a signal"}`,
+          stderrTail: tail(stderr)
+        });
+        return;
+      }
+      const receipt = parseReceipt(stdout);
+      if (!receipt) {
+        finish({
+          ok: false,
+          exitCode: 0,
+          message: "the bridge exited 0 but printed no parseable enrollment receipt",
+          stderrTail: tail(stderr)
+        });
+        return;
+      }
+      finish({ ok: true, receipt });
+    });
+  });
+}
+function tail(stderr) {
+  return sanitizeForTty(stderr).trim().slice(-STDERR_TAIL_CHARS);
+}
+function parseReceipt(stdout) {
+  const lines = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.startsWith("{")) continue;
+    try {
+      const data = JSON.parse(line);
+      if (data && typeof data === "object" && data["ok"] === true && typeof data["agentName"] === "string" && typeof data["agentUuid"] === "string") {
+        return {
+          ok: true,
+          agentName: data["agentName"],
+          agentUuid: data["agentUuid"],
+          relayUrl: typeof data["relayUrl"] === "string" ? data["relayUrl"] : "",
+          keystoreFile: typeof data["keystoreFile"] === "string" ? data["keystoreFile"] : ""
+        };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function startAgentProcess(opts) {
+  const [cmd, ...argv] = startArgv(opts.bridgeCmd, opts.name, opts.provider);
+  if (!cmd) return Promise.resolve(1);
+  return new Promise((resolve) => {
+    const child = spawn2(cmd, argv, { stdio: "inherit" });
+    child.on("error", () => resolve(1));
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/commands/agent.ts
+import readline from "readline/promises";
+var AGENT_USAGE = `usage: braid agent <add|status|reissue|revoke|remove> <name> [options]
+
+  add <name>      create a personal agent on Braid, enroll it on this machine
+                  via the local bridge, and start it (Ctrl-C stops it)
+  status <name>   detail card: presence, credential, health, service mode
+  reissue <name>  mint a fresh credential and re-enroll here \u2014 recovers an
+                  agent whose credential is broken or revoked
+  revoke <name>   revoke the agent's credential \u2014 it cannot connect until reissued
+  remove <name>   permanently delete the agent from Braid
+
+  --provider <p>      agent CLI the bridge runs (claude-code, codex, gemini, \u2026)
+  --no-start          enroll only \u2014 prints the exact start command instead
+  --bridge-cmd <cmd>  bridge command to spawn (default: npx -y arp-bridge@latest;
+                      also ARP_TUI_BRIDGE_CMD env)
+  --yes               skip the confirmation prompt (required with --json on
+                      revoke/remove)
+  --json              machine-readable result on stdout`;
+async function promptOnTty(question) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) return null;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+async function ensureSignedIn(deps) {
+  const existing = deps.resolveCreds();
+  if (existing?.token) return existing;
+  deps.err("you're not signed in yet \u2014 opening your browser to sign in to Braid\u2026");
+  return deps.runLogin();
+}
+function oneShotTokenSupplier(instance2, initial, refresh = refreshGrant) {
+  let current = initial;
+  return async () => {
+    const refreshable = !!current.refreshToken && boundToFapi(current.clerkFapiUrl, instance2.clerkFapiUrl);
+    if (refreshable && needsRefresh(current.expiresAt)) {
+      const consumed = current.refreshToken;
+      try {
+        const tokens = await refresh({
+          endpoints: oauthEndpoints(instance2.clerkFapiUrl),
+          clientId: requireOAuthClientId(instance2),
+          refreshToken: consumed
+        });
+        const fields = {
+          token: tokens.accessToken,
+          tokenType: "oauth",
+          // a slot holding a refresh token is ALWAYS an oauth slot
+          obtainedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          expiresAt: tokens.expiresAt ?? jwtExpiry(tokens.accessToken),
+          refreshToken: tokens.refreshToken ?? consumed
+        };
+        try {
+          updateCredentials(instance2.relayUrl, (onDisk) => mergeRotation(onDisk, fields, consumed));
+        } catch {
+        }
+        current = { ...current, ...fields };
+      } catch {
+      }
+    }
+    return current.token;
+  };
+}
+async function runAgentCli(instance2, args2, overrides = {}) {
+  const deps = {
+    resolveCreds: () => resolveCredentials(instance2, args2.flagToken),
+    runLogin: async () => (await login(instance2)).credentials,
+    enroll: enrollAgent,
+    startAgent: startAgentProcess,
+    env: process.env,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+    prompt: promptOnTty,
+    ...overrides
+  };
+  try {
+    if (args2.cmd === "agents") return await runAgentsList(instance2, args2, deps);
+    switch (args2.sub) {
+      case "add":
+        return await runAgentAdd(instance2, args2, deps);
+      case "status":
+        return await runAgentStatus(instance2, args2, deps);
+      case "reissue":
+        return await runAgentReissue(instance2, args2, deps);
+      case "revoke":
+        return await runAgentRevoke(instance2, args2, deps);
+      case "remove":
+        return await runAgentRemove(instance2, args2, deps);
+      default:
+        deps.err(AGENT_USAGE);
+        if (args2.sub) deps.err(`
+unknown agent command "${sanitizeLabel(args2.sub)}".`);
+        return 1;
+    }
+  } catch (err) {
+    deps.err(sanitizeForTty(err instanceof Error ? err.message : String(err)));
+    return 1;
+  }
+}
+function oneShotRest(instance2, creds) {
+  return new RelayRest({
+    relayUrl: instance2.relayUrl,
+    getToken: oneShotTokenSupplier(instance2, creds)
+  });
+}
+function requireName2(args2, deps) {
+  const name = args2.name?.trim();
+  if (!name) {
+    deps.err(`agent ${args2.sub} requires a name \u2014 usage: braid agent ${args2.sub} <name>`);
+    return null;
+  }
+  return name;
+}
+async function findMyAgent(rest, name, args2, deps) {
+  const agents = await rest.listMyAgents();
+  const found = agents.find((a) => a.name === name);
+  if (found) return found;
+  const msg = `no agent named "${sanitizeLabel(name)}"`;
+  if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+  const known = agents.map((a) => sanitizeLabel(a.name ?? "")).filter(Boolean);
+  deps.err(
+    `\u2717 ${msg}${known.length > 0 ? ` \u2014 your agents: ${known.join(", ")}` : " \u2014 you have no agents yet (run `braid agent add <name>`)"}`
+  );
+  return null;
+}
+async function confirmDestructive(args2, deps, name, actionLine) {
+  if (args2.yes) return true;
+  if (args2.json) {
+    deps.out(JSON.stringify({ ok: false, error: "--json runs non-interactively \u2014 add --yes to confirm" }));
+    deps.err(`\u2717 refusing: --json runs non-interactively \u2014 add --yes to confirm`);
+    return false;
+  }
+  const typed = await deps.prompt(`${actionLine}
+  type the agent name to confirm: `);
+  if (typed === null) {
+    deps.err("\u2717 refusing: no terminal to confirm on \u2014 re-run with --yes");
+    return false;
+  }
+  if (typed.trim() !== name) {
+    deps.err("\u2717 confirmation did not match \u2014 nothing was changed");
+    return false;
+  }
+  return true;
+}
+async function enrollAndMaybeStart(args2, deps, opts) {
+  const result = await deps.enroll({ bridgeCmd: opts.bridgeCmd, connectBlob: opts.connectBlob });
+  if (!result.ok) {
+    const msg = sanitizeForTty(result.message);
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 enrollment failed: ${msg}`);
+    if (result.stderrTail) deps.err(result.stderrTail);
+    return 1;
+  }
+  const agentName = result.receipt.agentName;
+  const started = !args2.noStart;
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({
+        ok: true,
+        agentName: sanitizeForTty(agentName),
+        agentUuid: sanitizeForTty(result.receipt.agentUuid),
+        enrolled: true,
+        started
+      })
+    );
+  }
+  deps.err(opts.successLine(sanitizeLabel(agentName)));
+  if (!started) {
+    deps.err(`  start it with: ${sanitizeForTty(startArgv(opts.bridgeCmd, agentName, args2.provider).join(" "))}`);
+    return 0;
+  }
+  deps.err(`\u2192 starting ${sanitizeLabel(agentName)} now \u2014 press Ctrl-C to stop it`);
+  return deps.startAgent({ bridgeCmd: opts.bridgeCmd, name: agentName, provider: args2.provider });
+}
+async function runAgentAdd(instance2, args2, deps) {
+  const name = requireName2(args2, deps);
+  if (!name) return 1;
+  const bridgeCmd = resolveBridgeCmd(args2.bridgeCmd, deps.env);
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  let invite;
+  try {
+    invite = await rest.createPersonalAgent(name);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not create "${sanitizeLabel(name)}": ${msg}`);
+    return 1;
+  }
+  deps.err(`\u2713 ${sanitizeLabel(name)} created on Braid \u2014 enrolling on this machine\u2026`);
+  return enrollAndMaybeStart(args2, deps, {
+    bridgeCmd,
+    connectBlob: invite.connectBlob,
+    successLine: (n) => `\u2714 ${n} is enrolled with Braid`
+  });
+}
+async function runAgentStatus(instance2, args2, deps) {
+  const name = requireName2(args2, deps);
+  if (!name) return 1;
+  const creds = await ensureSignedIn(deps);
+  const agent = await findMyAgent(oneShotRest(instance2, creds), name, args2, deps);
+  if (!agent) return 1;
+  if (args2.json) {
+    deps.out(JSON.stringify(agent, null, 2));
+    return 0;
+  }
+  const row = (label, value) => deps.out(`${(label + ":").padEnd(14)}${value}`);
+  row("agent", sanitizeLabel(agent.name ?? "", 64));
+  row("status", agent.status === "online" ? "online" : "offline");
+  const cred = sanitizeLabel(agent.credentialState ?? "none", 32);
+  row(
+    "credential",
+    agent.credentialLastUsedAt ? `${cred} (last used ${sanitizeLabel(agent.credentialLastUsedAt, 40)})` : cred
+  );
+  row("health", sanitizeLabel(agent.healthState ?? "unknown", 32));
+  if (agent.healthDetail) row("detail", sanitizeLabel(agent.healthDetail, 200));
+  if (agent.healthFixHint) row("fix", sanitizeLabel(agent.healthFixHint, 200));
+  row(
+    "service mode",
+    typeof agent.serviceMode === "boolean" ? agent.serviceMode ? "on" : "off" : sanitizeLabel(agent.serviceMode ?? "off", 20)
+  );
+  if (agent.runtimeVersion) row("runtime", sanitizeLabel(agent.runtimeVersion, 40));
+  if (agent.daemonPosture) row("daemon", sanitizeLabel(agent.daemonPosture, 40));
+  return 0;
+}
+async function runAgentReissue(instance2, args2, deps) {
+  const name = requireName2(args2, deps);
+  if (!name) return 1;
+  const bridgeCmd = resolveBridgeCmd(args2.bridgeCmd, deps.env);
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const agent = await findMyAgent(rest, name, args2, deps);
+  if (!agent) return 1;
+  let invite;
+  try {
+    invite = await rest.reissueAgent(agent.id);
+  } catch (err) {
+    const msg = err instanceof RelayError && err.status === 429 ? "reissue is rate-limited \u2014 wait a minute and try again" : sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not reissue "${sanitizeLabel(name)}": ${msg}`);
+    return 1;
+  }
+  deps.err(`\u2713 fresh credential minted \u2014 re-enrolling ${sanitizeLabel(name)} on this machine\u2026`);
+  return enrollAndMaybeStart(args2, deps, {
+    bridgeCmd,
+    connectBlob: invite.connectBlob,
+    successLine: (n) => `\u2714 ${n} reconnected to Braid`
+  });
+}
+async function runAgentRevoke(instance2, args2, deps) {
+  const name = requireName2(args2, deps);
+  if (!name) return 1;
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const agent = await findMyAgent(rest, name, args2, deps);
+  if (!agent) return 1;
+  const confirmed = await confirmDestructive(
+    args2,
+    deps,
+    name,
+    `this revokes "${sanitizeLabel(name)}"'s credential and disconnects it from Braid.`
+  );
+  if (!confirmed) return 1;
+  let credential;
+  try {
+    credential = await rest.revokeAgentCredential(agent.id);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not revoke "${sanitizeLabel(name)}": ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({
+        ok: true,
+        agentName: sanitizeForTty(name),
+        credentialState: sanitizeForTty(credential.state ?? "revoked_owner")
+      })
+    );
+  }
+  deps.err(
+    `\u2714 credential revoked \u2014 ${sanitizeLabel(name)} can no longer connect to Braid until you run \`braid agent reissue ${sanitizeLabel(name)}\``
+  );
+  return 0;
+}
+async function runAgentRemove(instance2, args2, deps) {
+  const name = requireName2(args2, deps);
+  if (!name) return 1;
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const agent = await findMyAgent(rest, name, args2, deps);
+  if (!agent) return 1;
+  const confirmed = await confirmDestructive(
+    args2,
+    deps,
+    name,
+    `this permanently deletes agent "${sanitizeLabel(name)}" from Braid \u2014 identity, credential, and channel memberships.`
+  );
+  if (!confirmed) return 1;
+  try {
+    await rest.deleteAgent(agent.id);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not remove "${sanitizeLabel(name)}": ${msg}`);
+    return 1;
+  }
+  if (args2.json) deps.out(JSON.stringify({ ok: true, agentName: sanitizeForTty(name), removed: true }));
+  deps.err(
+    `\u2714 ${sanitizeLabel(name)} removed from Braid \u2014 its identity, credential, and channel memberships are deleted; messages it already posted stay in channel history`
+  );
+  return 0;
+}
+async function runAgentsList(instance2, args2, deps) {
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  let agents;
+  try {
+    agents = await rest.listMyAgents();
+  } catch (err) {
+    deps.err(
+      `\u2717 Braid could not list your agents: ${sanitizeForTty(err instanceof Error ? err.message : String(err))}`
+    );
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(JSON.stringify(agents, null, 2));
+    return 0;
+  }
+  if (agents.length === 0) {
+    deps.out("(no agents yet \u2014 run `braid agent add <name>` to create one)");
+    return 0;
+  }
+  deps.out(`${"NAME".padEnd(24)} ${"STATUS".padEnd(8)} CREDENTIAL`);
+  for (const a of agents) {
+    const status = a.status === "online" ? "online" : "offline";
+    deps.out(
+      `${sanitizeLabel(a.name ?? "", 24).padEnd(24)} ${status.padEnd(8)} ${sanitizeLabel(a.credentialState ?? "-", 20)}`
+    );
+  }
+  return 0;
+}
+
+// src/commands/channel.ts
+var CHANNEL_USAGE = `usage: braid channels [--all] [--json]
+       braid channel <create|archive|unarchive|members|member> \u2026
+
+  channels                  list your channels (--all includes archived)
+  create <name>             create a channel on Braid (you become its owner)
+  archive <name-or-id>      archive a channel \u2014 it leaves everyone's sidebar
+                            (reversible; y/N confirm, --yes skips)
+  unarchive <name-or-id>    restore an archived channel
+  members <name-or-id>      list a channel's members (humans and agents)
+  member add <channel> <agent>
+                            add one of your agents to a channel
+  member remove <channel> <agent>
+                            remove an agent from a channel (y/N confirm, --yes)
+
+  --all   include archived channels when listing
+  --yes   skip the confirmation prompt (required with --json on
+          archive/member remove)
+  --json  machine-readable result on stdout
+
+channels are archive-only \u2014 there is no delete. archive to retire one.`;
+async function runChannelCli(instance2, args2, overrides = {}) {
+  const deps = {
+    resolveCreds: () => resolveCredentials(instance2, args2.flagToken),
+    runLogin: async () => (await login(instance2)).credentials,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+    prompt: promptOnTty,
+    ...overrides
+  };
+  try {
+    if (args2.cmd === "channels") return await runChannelsList(instance2, args2, deps);
+    switch (args2.sub) {
+      case "create":
+        return await runChannelCreate(instance2, args2, deps);
+      case "archive":
+        return await runChannelArchive(instance2, args2, deps);
+      case "unarchive":
+        return await runChannelUnarchive(instance2, args2, deps);
+      case "members":
+        return await runChannelMembers(instance2, args2, deps);
+      case "member":
+        return await runChannelMember(instance2, args2, deps);
+      default:
+        deps.err(CHANNEL_USAGE);
+        if (args2.sub) deps.err(`
+unknown channel command "${sanitizeLabel(args2.sub)}".`);
+        return 1;
+    }
+  } catch (err) {
+    deps.err(sanitizeForTty(err instanceof Error ? err.message : String(err)));
+    return 1;
+  }
+}
+async function fetchChannels(rest, scope) {
+  const rows = [];
+  if (scope !== "archived") {
+    rows.push(...(await rest.listChannels()).map((c) => ({ ...c, archived: false })));
+  }
+  if (scope !== "active") {
+    rows.push(...(await rest.listArchivedChannels()).map((c) => ({ ...c, archived: true })));
+  }
+  return rows;
+}
+async function resolveChannel(rest, ref, scope, args2, deps) {
+  const rows = await fetchChannels(rest, scope);
+  const byId = rows.find((c) => c.id === ref);
+  if (byId) return byId;
+  const byName = rows.filter((c) => sanitizeForTty(c.name ?? "") === ref);
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) {
+    const msg2 = `channel name "${sanitizeLabel(ref)}" is ambiguous \u2014 use the id`;
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg2 }));
+    deps.err(`\u2717 ${msg2}:`);
+    for (const c of byName) {
+      deps.err(
+        `  ${sanitizeLabel(c.name ?? "", 24).padEnd(24)} ${sanitizeLabel(c.id ?? "", 40)}${c.archived ? "  (archived)" : ""}`
+      );
+    }
+    return null;
+  }
+  const noun = scope === "archived" ? "archived channel" : "channel";
+  const msg = `no ${noun} named "${sanitizeLabel(ref)}"`;
+  if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+  const known = rows.map((c) => sanitizeLabel(c.name ?? "")).filter(Boolean);
+  deps.err(
+    `\u2717 ${msg}${known.length > 0 ? ` \u2014 your ${scope === "archived" ? "archived channels" : "channels"}: ${known.join(", ")}` : scope === "archived" ? " \u2014 you have no archived channels" : " \u2014 you have no channels yet (run `braid channel create <name>`)"}`
+  );
+  return null;
+}
+async function confirmSimple(args2, deps, actionLine) {
+  if (args2.yes) return true;
+  if (args2.json) {
+    deps.out(JSON.stringify({ ok: false, error: "--json runs non-interactively \u2014 add --yes to confirm" }));
+    deps.err("\u2717 refusing: --json runs non-interactively \u2014 add --yes to confirm");
+    return false;
+  }
+  const typed = await deps.prompt(`${actionLine} [y/N] `);
+  if (typed === null) {
+    deps.err("\u2717 refusing: no terminal to confirm on \u2014 re-run with --yes");
+    return false;
+  }
+  if (!/^y(es)?$/i.test(typed.trim())) {
+    deps.err("\u2717 not confirmed \u2014 nothing was changed");
+    return false;
+  }
+  return true;
+}
+function shortId(id) {
+  return sanitizeLabel(id ?? "", 40).slice(0, 8);
+}
+async function runChannelsList(instance2, args2, deps) {
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const rows = await fetchChannels(rest, args2.all ? "all" : "active");
+  if (args2.json) {
+    deps.out(JSON.stringify(rows, null, 2));
+    return 0;
+  }
+  if (rows.length === 0) {
+    deps.out("(no channels yet \u2014 run `braid channel create <name>` to make one)");
+    return 0;
+  }
+  deps.out(`${"NAME".padEnd(24)} ${"ID".padEnd(10)}${args2.all ? " STATE" : ""}`);
+  for (const c of rows) {
+    deps.out(
+      `${sanitizeLabel(c.name ?? "", 24).padEnd(24)} ${shortId(c.id).padEnd(10)}${args2.all ? ` ${c.archived ? "archived" : "active"}` : ""}`
+    );
+  }
+  return 0;
+}
+async function runChannelCreate(instance2, args2, deps) {
+  const name = args2.rest[0]?.trim();
+  if (!name) {
+    deps.err("channel create requires a name \u2014 usage: braid channel create <name>");
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  let ch;
+  try {
+    ch = await rest.createChannel(name);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not create channel "${sanitizeLabel(name)}": ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(JSON.stringify({ ok: true, id: sanitizeForTty(ch.id ?? ""), name: sanitizeForTty(ch.name ?? "") }));
+  }
+  deps.err(
+    `\u2714 #${sanitizeLabel(ch.name ?? name)} created on Braid (id ${shortId(ch.id)}) \u2014 add an agent with \`braid channel member add ${sanitizeLabel(ch.name ?? name)} <agent>\``
+  );
+  return 0;
+}
+async function runChannelArchive(instance2, args2, deps) {
+  const ref = args2.rest[0]?.trim();
+  if (!ref) {
+    deps.err("channel archive requires a name \u2014 usage: braid channel archive <name-or-id>");
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const ch = await resolveChannel(rest, ref, "active", args2, deps);
+  if (!ch) return 1;
+  const name = sanitizeLabel(ch.name ?? "");
+  const confirmed = await confirmSimple(
+    args2,
+    deps,
+    `archive #${name}? it leaves everyone's sidebar (\`braid channel unarchive ${name}\` restores it).`
+  );
+  if (!confirmed) return 1;
+  try {
+    await rest.archiveChannel(ch.id);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not archive #${name}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({ ok: true, id: sanitizeForTty(ch.id), name: sanitizeForTty(ch.name ?? ""), archived: true })
+    );
+  }
+  deps.err(`\u2714 #${name} archived \u2014 bring it back any time with \`braid channel unarchive ${name}\``);
+  return 0;
+}
+async function runChannelUnarchive(instance2, args2, deps) {
+  const ref = args2.rest[0]?.trim();
+  if (!ref) {
+    deps.err("channel unarchive requires a name \u2014 usage: braid channel unarchive <name-or-id>");
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const ch = await resolveChannel(rest, ref, "archived", args2, deps);
+  if (!ch) return 1;
+  const name = sanitizeLabel(ch.name ?? "");
+  try {
+    await rest.unarchiveChannel(ch.id);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not unarchive #${name}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({ ok: true, id: sanitizeForTty(ch.id), name: sanitizeForTty(ch.name ?? ""), archived: false })
+    );
+  }
+  deps.err(`\u2714 #${name} is back \u2014 restored from the archive`);
+  return 0;
+}
+async function runChannelMembers(instance2, args2, deps) {
+  const ref = args2.rest[0]?.trim();
+  if (!ref) {
+    deps.err("channel members requires a channel \u2014 usage: braid channel members <name-or-id>");
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const ch = await resolveChannel(rest, ref, "all", args2, deps);
+  if (!ch) return 1;
+  if (args2.json) {
+    deps.out(JSON.stringify(ch.members, null, 2));
+    return 0;
+  }
+  if (ch.members.length === 0) {
+    deps.out(`(no members in #${sanitizeLabel(ch.name ?? "")})`);
+    return 0;
+  }
+  deps.out(`${"NAME".padEnd(24)} ${"TYPE".padEnd(6)} ${"ROLE".padEnd(7)} STATUS`);
+  for (const m of ch.members) {
+    deps.out(
+      `${sanitizeLabel(m.name, 24).padEnd(24)} ${m.type.padEnd(6)} ${sanitizeLabel(m.role, 7).padEnd(7)} ${m.status}`
+    );
+  }
+  return 0;
+}
+async function runChannelMember(instance2, args2, deps) {
+  const [action, channelRef, agentName] = args2.rest.map((s) => s?.trim());
+  const usage = "usage: braid channel member <add|remove> <channel> <agent-name>";
+  if (action !== "add" && action !== "remove" || !channelRef || !agentName) {
+    deps.err(usage);
+    if (action && action !== "add" && action !== "remove") {
+      deps.err(`
+unknown member action "${sanitizeLabel(action)}".`);
+    }
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const ch = await resolveChannel(rest, channelRef, "active", args2, deps);
+  if (!ch) return 1;
+  return action === "add" ? runMemberAdd(rest, ch, agentName, args2, deps) : runMemberRemove(rest, ch, agentName, args2, deps);
+}
+async function runMemberAdd(rest, ch, agentName, args2, deps) {
+  const chName = sanitizeLabel(ch.name ?? "");
+  const agent = await findMyAgent(rest, agentName, args2, deps);
+  if (!agent) return 1;
+  try {
+    await rest.addAgentToChannel(ch.id, agent.id);
+  } catch (err) {
+    let msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (msg.includes("guest_agents_disabled")) {
+      msg = "this organization does not allow guest agents \u2014 enable it in org settings or ask an admin";
+    }
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not add "${sanitizeLabel(agentName)}" to #${chName}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({
+        ok: true,
+        channelId: sanitizeForTty(ch.id),
+        channel: sanitizeForTty(ch.name ?? ""),
+        agent: sanitizeForTty(agent.name),
+        added: true
+      })
+    );
+  }
+  deps.err(`\u2714 ${sanitizeLabel(agent.name)} joined #${chName} \u2014 it now sees the channel and can post there`);
+  return 0;
+}
+async function runMemberRemove(rest, ch, agentName, args2, deps) {
+  const chName = sanitizeLabel(ch.name ?? "");
+  const member = ch.members.find((m) => m.type === "bot" && m.id === agentName);
+  if (!member) {
+    const msg = `"${sanitizeLabel(agentName)}" is not a member of #${chName}`;
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    const bots = ch.members.filter((m) => m.type === "bot").map((m) => sanitizeLabel(m.name));
+    deps.err(`\u2717 ${msg}${bots.length > 0 ? ` \u2014 its agents: ${bots.join(", ")}` : " \u2014 it has no agents"}`);
+    return 1;
+  }
+  const confirmed = await confirmSimple(
+    args2,
+    deps,
+    `remove ${sanitizeLabel(agentName)} from #${chName}? it stops seeing the channel (member add restores it).`
+  );
+  if (!confirmed) return 1;
+  try {
+    await rest.removeChannelMember(ch.id, member.id);
+  } catch (err) {
+    const msg = sanitizeForTty(err instanceof Error ? err.message : String(err));
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not remove "${sanitizeLabel(agentName)}" from #${chName}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({
+        ok: true,
+        channelId: sanitizeForTty(ch.id),
+        channel: sanitizeForTty(ch.name ?? ""),
+        agent: sanitizeForTty(agentName),
+        removed: true
+      })
+    );
+  }
+  deps.err(
+    `\u2714 ${sanitizeLabel(agentName)} removed from #${chName} \u2014 add it back any time with \`braid channel member add ${chName} ${sanitizeLabel(agentName)}\``
+  );
+  return 0;
+}
+
+// src/commands/invite.ts
+var INVITE_USAGE = `usage: braid invites [<channel>] [--all] [--json]
+       braid invite <agent|human|revoke> \u2026
+
+  invites                   list your org's channel-less agent invites
+  invites <channel>         list a channel's agent invites
+                            (active only; --all includes revoked/expired/used)
+  agent <channel> <name>    mint an invite for a NEW agent named <name> on the
+                            channel \u2014 prints the join command ONCE (org admin)
+  human <channel> <email>   invite a human by email: they get a Braid email and
+                            land in the channel (org admin; a user from another
+                            org joins this channel only, as a guest)
+  revoke <invite-id>        revoke an org-wide invite so it cannot be redeemed
+                            (y/N confirm, --yes skips)
+    --channel <channel>     revoke a CHANNEL invite instead (the id alone
+                            targets the org-wide route)
+
+  --all   include revoked/expired/exhausted invites when listing
+  --yes   skip the confirmation prompt (required with --json on revoke)
+  --json  machine-readable result on stdout
+
+minting and managing invites needs org admin on Braid.`;
+async function runInviteCli(instance2, args2, overrides = {}) {
+  const deps = {
+    resolveCreds: () => resolveCredentials(instance2, args2.flagToken),
+    runLogin: async () => (await login(instance2)).credentials,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+    prompt: promptOnTty,
+    ...overrides
+  };
+  try {
+    if (args2.cmd === "invites") return await runInvitesList(instance2, args2, deps);
+    switch (args2.sub) {
+      case "agent":
+        return await runInviteAgent(instance2, args2, deps);
+      case "human":
+        return await runInviteHuman(instance2, args2, deps);
+      case "revoke":
+        return await runInviteRevoke(instance2, args2, deps);
+      default:
+        deps.err(INVITE_USAGE);
+        if (args2.sub) deps.err(`
+unknown invite command "${sanitizeLabel(args2.sub)}".`);
+        return 1;
+    }
+  } catch (err) {
+    deps.err(sanitizeForTty(err instanceof Error ? err.message : String(err)));
+    return 1;
+  }
+}
+function inviteErrorMessage(err) {
+  if (err instanceof RelayError) {
+    if (err.status === 403 && err.message === "admin_required") {
+      return "you need to be an org admin on Braid to do this \u2014 ask an admin, or have them grant you the role";
+    }
+    if (err.status === 403 && err.message === "guest_agents_disabled") {
+      return "this organization does not allow guest agents \u2014 enable it in org settings or ask an admin";
+    }
+    if (err.status === 402 && err.message === "seat_limit_reached") {
+      return "the organization is out of member seats \u2014 upgrade the plan to invite more humans";
+    }
+    if (err.status === 402 && err.message === "guest_limit_reached") {
+      return "the organization is at its guest limit \u2014 upgrade the plan to add more guests";
+    }
+  }
+  return sanitizeForTty(err instanceof Error ? err.message : String(err));
+}
+async function runInviteAgent(instance2, args2, deps) {
+  const [channelRef, name] = args2.rest.map((s) => s?.trim());
+  if (!channelRef || !name) {
+    deps.err("usage: braid invite agent <channel> <agent-name>");
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const ch = await resolveChannel(rest, channelRef, "active", args2, deps);
+  if (!ch) return 1;
+  const chName = sanitizeLabel(ch.name ?? "");
+  let mint;
+  try {
+    mint = await rest.createChannelAgentInvite(ch.id, name);
+  } catch (err) {
+    const msg = inviteErrorMessage(err);
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not mint an invite for "${sanitizeLabel(name)}" on #${chName}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(JSON.stringify(mint));
+    return 0;
+  }
+  deps.err(`\u2714 invite minted for agent "${sanitizeLabel(name)}" on #${chName} (invite ${shortId(mint.inviteId)})`);
+  deps.err("  run this on the agent's machine to join:");
+  deps.out(sanitizeForTty(mint.joinCommand));
+  deps.err(
+    `\u26A0 shown once \u2014 Braid keeps only a hash and this terminal will not show it again` + (mint.expiresAt ? ` (expires ${sanitizeLabel(mint.expiresAt)}` : ` (never expires`) + `${mint.oneTime ? ", single use)" : ")"}`
+  );
+  return 0;
+}
+function usesCell(inv) {
+  return `${inv.uses}/${inv.maxUses === 0 ? "\u221E" : inv.maxUses}`;
+}
+async function runInvitesList(instance2, args2, deps) {
+  const channelRef = args2.rest[0]?.trim();
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  let ch = null;
+  let invites;
+  try {
+    if (channelRef) {
+      ch = await resolveChannel(rest, channelRef, "all", args2, deps);
+      if (!ch) return 1;
+      invites = await rest.listChannelAgentInvites(ch.id);
+    } else {
+      invites = await rest.listOrgAgentInvites();
+    }
+  } catch (err) {
+    const msg = inviteErrorMessage(err);
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not list invites: ${msg}`);
+    return 1;
+  }
+  if (!args2.all) invites = invites.filter((i) => i.status === "active");
+  if (args2.json) {
+    deps.out(JSON.stringify(invites, null, 2));
+    return 0;
+  }
+  const where = ch ? `#${sanitizeLabel(ch.name ?? "")}` : "your organization (channel-less invites)";
+  if (invites.length === 0) {
+    deps.out(`(no ${args2.all ? "" : "active "}invites for ${where})`);
+    return 0;
+  }
+  deps.err(`invites for ${where}:`);
+  deps.out(
+    `${"ID".padEnd(10)} ${"AGENT".padEnd(24)} ${"CHANNEL".padEnd(16)} ${"CREATED".padEnd(21)} ${"EXPIRES".padEnd(21)} ${"USES".padEnd(5)} STATUS`
+  );
+  for (const inv of invites) {
+    const channelCell = ch ? sanitizeLabel(ch.name ?? "", 16) : "-";
+    deps.out(
+      `${shortId(inv.id).padEnd(10)} ${sanitizeLabel(inv.agentName ?? "", 24).padEnd(24)} ${channelCell.padEnd(16)} ${sanitizeLabel(inv.createdAt ?? "", 21).padEnd(21)} ${sanitizeLabel(inv.expiresAt ?? "never", 21).padEnd(21)} ${usesCell(inv).padEnd(5)} ` + sanitizeLabel(inv.status ?? "", 12)
+    );
+  }
+  return 0;
+}
+async function runInviteRevoke(instance2, args2, deps) {
+  const inviteId = args2.rest[0]?.trim();
+  if (!inviteId) {
+    deps.err("invite revoke requires an id \u2014 usage: braid invite revoke <invite-id> [--channel <channel>]");
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  let ch = null;
+  if (args2.channel) {
+    ch = await resolveChannel(rest, args2.channel.trim(), "all", args2, deps);
+    if (!ch) return 1;
+  }
+  const where = ch ? `#${sanitizeLabel(ch.name ?? "")}` : "your organization";
+  const confirmed = await confirmSimple(
+    args2,
+    deps,
+    `revoke invite ${sanitizeLabel(inviteId, 40)} on ${where}? it can no longer be redeemed (an agent that already joined stays connected).`
+  );
+  if (!confirmed) return 1;
+  try {
+    if (ch) await rest.revokeChannelAgentInvite(ch.id, inviteId);
+    else await rest.revokeOrgAgentInvite(inviteId);
+  } catch (err) {
+    let msg = inviteErrorMessage(err);
+    if (err instanceof RelayError && err.status === 404 && !ch) {
+      msg = `invite not found org-wide \u2014 a channel invite needs --channel <channel>`;
+    }
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not revoke invite ${sanitizeLabel(inviteId, 40)}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(
+      JSON.stringify({
+        ok: true,
+        inviteId: sanitizeForTty(inviteId),
+        ...ch ? { channelId: sanitizeForTty(ch.id), channel: sanitizeForTty(ch.name ?? "") } : {},
+        revoked: true
+      })
+    );
+  }
+  deps.err(`\u2714 invite ${sanitizeLabel(inviteId, 40)} revoked \u2014 it can no longer be redeemed`);
+  return 0;
+}
+function looksLikeEmail(email) {
+  return /^[^\s@]+@[^\s@]+$/.test(email);
+}
+async function runInviteHuman(instance2, args2, deps) {
+  const [channelRef, emailRaw] = args2.rest.map((s) => s?.trim());
+  if (!channelRef || !emailRaw) {
+    deps.err("usage: braid invite human <channel> <email>");
+    return 1;
+  }
+  const email = emailRaw.toLowerCase();
+  if (!looksLikeEmail(email)) {
+    const msg = `"${sanitizeLabel(emailRaw)}" does not look like an email address`;
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 ${msg}`);
+    return 1;
+  }
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const ch = await resolveChannel(rest, channelRef, "active", args2, deps);
+  if (!ch) return 1;
+  const chName = sanitizeLabel(ch.name ?? "");
+  let result;
+  try {
+    result = await rest.inviteHumanToChannel(ch.id, email);
+  } catch (err) {
+    const msg = inviteErrorMessage(err);
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not invite ${sanitizeLabel(email)} to #${chName}: ${msg}`);
+    return 1;
+  }
+  if (args2.json) {
+    deps.out(JSON.stringify(result));
+    return 0;
+  }
+  if (result.note) {
+    deps.err(`\u2714 ${sanitizeLabel(email)} \u2014 ${sanitizeLabel(result.note, 80)}`);
+  } else if (result.guest) {
+    deps.err(
+      `\u2714 ${sanitizeLabel(email)} added to #${chName} as a cross-org guest \u2014 they see this channel only, not your org directory`
+    );
+  } else {
+    deps.err(
+      `\u2714 ${sanitizeLabel(email)} invited \u2014 Braid emailed them; they'll land in #${chName} when they accept`
+    );
+  }
+  return 0;
+}
+
+// src/commands/org.ts
+var ORG_USAGE = `usage: braid org [--json]
+       braid org guest-agents <on|off> [--yes] [--json]
+
+  org                     show your organization: id and whether guest agents
+                          (agents owned outside the org) are allowed in
+  guest-agents on|off     allow or block guest agents org-wide \u2014 this changes
+                          live cross-org access, so it asks y/N (--yes skips;
+                          org admin only)
+
+  --yes   skip the confirmation prompt (required with --json on guest-agents)
+  --json  machine-readable result on stdout`;
+async function runOrgCli(instance2, args2, overrides = {}) {
+  const deps = {
+    resolveCreds: () => resolveCredentials(instance2, args2.flagToken),
+    runLogin: async () => (await login(instance2)).credentials,
+    out: (line) => console.log(line),
+    err: (line) => console.error(line),
+    prompt: promptOnTty,
+    ...overrides
+  };
+  try {
+    if (!args2.sub) return await runOrgShow(instance2, args2, deps);
+    if (args2.sub === "guest-agents") return await runOrgGuestAgents(instance2, args2, deps);
+    deps.err(ORG_USAGE);
+    deps.err(`
+unknown org command "${sanitizeLabel(args2.sub)}".`);
+    return 1;
+  } catch (err) {
+    deps.err(sanitizeForTty(err instanceof Error ? err.message : String(err)));
+    return 1;
+  }
+}
+function orgErrorMessage(err) {
+  if (err instanceof RelayError) {
+    if (err.status === 403 && err.message === "admin_required") {
+      return "you need to be an org admin on Braid to change org settings";
+    }
+    if (err.status === 404) {
+      return "no active organization \u2014 sign in on Braid web and pick an organization first";
+    }
+  }
+  return sanitizeForTty(err instanceof Error ? err.message : String(err));
+}
+async function fetchMyOrg(rest, args2, deps) {
+  try {
+    return await rest.getMyOrganization();
+  } catch (err) {
+    const msg = orgErrorMessage(err);
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not read your organization: ${msg}`);
+    return null;
+  }
+}
+async function runOrgShow(instance2, args2, deps) {
+  const creds = await ensureSignedIn(deps);
+  const org = await fetchMyOrg(oneShotRest(instance2, creds), args2, deps);
+  if (!org) return 1;
+  if (args2.json) {
+    deps.out(JSON.stringify(org, null, 2));
+    return 0;
+  }
+  const row = (label, value) => deps.out(`${(label + ":").padEnd(14)}${value}`);
+  row("org id", sanitizeLabel(org.id ?? "", 40));
+  row("guest agents", org.allowGuestAgents ? "allowed \u2014 agents owned outside the org may join channels" : "blocked");
+  return 0;
+}
+async function runOrgGuestAgents(instance2, args2, deps) {
+  const value = args2.rest[0]?.trim();
+  if (value !== "on" && value !== "off") {
+    deps.err("usage: braid org guest-agents <on|off>");
+    if (value) deps.err(`
+unknown value "${sanitizeLabel(value)}" \u2014 say on or off.`);
+    return 1;
+  }
+  const allow = value === "on";
+  const creds = await ensureSignedIn(deps);
+  const rest = oneShotRest(instance2, creds);
+  const org = await fetchMyOrg(rest, args2, deps);
+  if (!org) return 1;
+  if (org.allowGuestAgents === allow) {
+    if (args2.json) deps.out(JSON.stringify({ ok: true, allowGuestAgents: allow, changed: false }));
+    deps.err(`\u2714 guest agents are already ${allow ? "allowed" : "blocked"} \u2014 nothing to change`);
+    return 0;
+  }
+  const confirmed = await confirmSimple(
+    args2,
+    deps,
+    allow ? "allow guest agents? agents owned OUTSIDE your org can then be invited into your channels." : "block guest agents? no NEW cross-org agents or human guests can join your channels (current members are not removed)."
+  );
+  if (!confirmed) return 1;
+  try {
+    await rest.patchOrganization(org.id, { allowGuestAgents: allow });
+  } catch (err) {
+    const msg = orgErrorMessage(err);
+    if (args2.json) deps.out(JSON.stringify({ ok: false, error: msg }));
+    deps.err(`\u2717 Braid could not update the guest-agent policy: ${msg}`);
+    return 1;
+  }
+  if (args2.json) deps.out(JSON.stringify({ ok: true, allowGuestAgents: allow, changed: true }));
+  deps.err(
+    allow ? "\u2714 guest agents allowed \u2014 cross-org agents can now be invited into your channels" : "\u2714 guest agents blocked \u2014 new cross-org agents and guests can no longer join your channels"
+  );
+  return 0;
+}
+
 // src/index.tsx
-import { jsx as jsx12 } from "react/jsx-runtime";
+import { jsx as jsx13 } from "react/jsx-runtime";
 function helpText(profileName2, base2, effective) {
   const relayOverridden = effective.relayUrl !== base2.relayUrl;
   const overrideNote = relayOverridden ? `
@@ -2857,7 +4754,7 @@ function helpText(profileName2, base2, effective) {
                    instance \u2014 a JWT minted there will NOT work against the override)` : "";
   return `arp-tui \u2014 tail + post for Agent Relay Protocol channels (as the HUMAN)
 
-usage: arp-tui [tail|login|logout|status|profile] [--profile <name>] [--relay <url>] [--token <jwt>]
+usage: arp-tui [tail|login|logout|status|profile|agent <verb>|agents|channel <verb>|channels|invite <verb>|invites|org] [--profile <name>] [--relay <url>] [--token <jwt>]
 
 commands:
   tail            live channel tail + post (default)
@@ -2866,6 +4763,34 @@ commands:
   logout          revoke the OAuth grant and delete this instance's stored tokens
   status          show the stored credential state for the active instance
   profile         manage saved instances (list|add|switch|remove; run \`arp-tui profile\`)
+  agent add <name> create a personal agent on Braid, enroll it on this machine
+                  via the local bridge, and start it (--no-start to skip;
+                  --bridge-cmd/--provider/--json \u2014 run \`arp-tui agent\` for details)
+  agent status|reissue|revoke|remove <name>
+                  inspect or recover an agent: detail card, fresh credential +
+                  re-enroll, credential revoke, permanent delete (revoke/remove
+                  confirm on the TTY; --yes with --json)
+  agents          list your agents: name, online/offline, credential state (--json)
+  channels        list your channels (--all includes archived; --json)
+  channel create|archive|unarchive|members <name-or-id>
+                  channel lifecycle: create, archive (reversible; y/N confirm,
+                  --yes skips), restore, roster (run \`arp-tui channel\` for details)
+  channel member add|remove <channel> <agent>
+                  add or remove one of your agents on a channel
+  invites [<channel>]
+                  list agent invites: the org's channel-less invites, or one
+                  channel's (--all includes revoked/expired; --json)
+  invite agent <channel> <name>
+                  mint a channel invite for a NEW agent \u2014 prints the join
+                  command ONCE (org admin; run \`arp-tui invite\` for details)
+  invite human <channel> <email>
+                  invite a human by email into the channel (org admin)
+  invite revoke <invite-id> [--channel <ch>]
+                  revoke an invite (y/N confirm, --yes skips)
+  org             show your organization: id + guest-agent policy (--json)
+  org guest-agents on|off
+                  allow or block cross-org guest agents org-wide (org admin;
+                  y/N confirm, --yes skips)
 
 options:
   --profile <name> instance profile from ~/.arp-tui/config.json
@@ -2899,6 +4824,12 @@ function parseCliArgs(argv) {
         "clerk-fapi": { type: "string" },
         "clerk-template": { type: "string" },
         "clerk-oauth-client-id": { type: "string" },
+        provider: { type: "string" },
+        "no-start": { type: "boolean" },
+        "bridge-cmd": { type: "string" },
+        channel: { type: "string" },
+        all: { type: "boolean" },
+        yes: { type: "boolean" },
         json: { type: "boolean" },
         help: { type: "boolean", short: "h" }
       },
@@ -2912,6 +4843,7 @@ function parseCliArgs(argv) {
     cmd: parsed.positionals[0] ?? "tail",
     sub: parsed.positionals[1],
     name: parsed.positionals[2],
+    positionals: parsed.positionals,
     profile: parsed.values.profile,
     relay: parsed.values.relay,
     token: parsed.values.token,
@@ -2919,6 +4851,12 @@ function parseCliArgs(argv) {
     clerkFapi: parsed.values["clerk-fapi"],
     clerkTemplate: parsed.values["clerk-template"],
     clerkOAuthClientId: parsed.values["clerk-oauth-client-id"],
+    provider: parsed.values.provider,
+    noStart: parsed.values["no-start"] === true,
+    bridgeCmd: parsed.values["bridge-cmd"],
+    channel: parsed.values.channel,
+    all: parsed.values.all === true,
+    yes: parsed.values.yes === true,
     json: parsed.values.json === true,
     help: parsed.values.help === true
   };
@@ -3026,6 +4964,53 @@ if (args.cmd === "login") {
     }
   }
   process.exit(0);
+} else if (args.cmd === "agent" || args.cmd === "agents") {
+  const code = await runAgentCli(instance, {
+    cmd: args.cmd,
+    sub: args.sub,
+    name: args.name,
+    provider: args.provider,
+    noStart: args.noStart,
+    bridgeCmd: args.bridgeCmd,
+    yes: args.yes,
+    json: args.json,
+    flagToken: args.token
+  });
+  process.exit(code);
+} else if (args.cmd === "channel" || args.cmd === "channels") {
+  const code = await runChannelCli(instance, {
+    cmd: args.cmd,
+    sub: args.sub,
+    rest: args.positionals.slice(2),
+    all: args.all,
+    yes: args.yes,
+    json: args.json,
+    flagToken: args.token
+  });
+  process.exit(code);
+} else if (args.cmd === "invite" || args.cmd === "invites") {
+  const code = await runInviteCli(instance, {
+    cmd: args.cmd,
+    sub: args.sub,
+    // `invites [<channel>]` has no subcommand — its positionals start right after the verb
+    rest: args.cmd === "invites" ? args.positionals.slice(1) : args.positionals.slice(2),
+    channel: args.channel,
+    all: args.all,
+    yes: args.yes,
+    json: args.json,
+    flagToken: args.token
+  });
+  process.exit(code);
+} else if (args.cmd === "org") {
+  const code = await runOrgCli(instance, {
+    cmd: args.cmd,
+    sub: args.sub,
+    rest: args.positionals.slice(2),
+    yes: args.yes,
+    json: args.json,
+    flagToken: args.token
+  });
+  process.exit(code);
 } else if (args.cmd !== "tail") {
   console.error(`unknown command "${args.cmd}" \u2014 try --help.`);
   process.exit(1);
@@ -3043,4 +5028,4 @@ if (credentials?.tokenType === "dev-jwt" && credentials.token && !credentials.cl
   );
 }
 var store = createStore({ instance, credentials });
-render(/* @__PURE__ */ jsx12(App, { store }));
+render(/* @__PURE__ */ jsx13(App, { store }));