@scp-dev/broker 0.1.3 → 0.1.4

package/dist/index.js

@@ -1060,11 +1060,11 @@ import { setTimeout as sleep2 } from "timers/promises";
 import {
   BROKER_CAPABILITIES,
   CLI_NAME,
-  LIMITS as LIMITS2,
+  LIMITS,
   parsePolicy,
   PREAMBLE,
   PROTOCOL as PROTOCOL3,
-  RelayError as RelayError4,
+  RelayError as RelayError3,
   SERVER_FIELDS,
   stripControl
 } from "@scp-dev/core";
@@ -1072,460 +1072,20 @@ import { FederatedCore } from "@scp-dev/hub";
 
 // src/judge-gate.ts
 import { accessSync, constants, readFileSync as readFileSync4 } from "fs";
-import {
-  applyRedactions,
-  DEFAULT_JUDGE_BUDGET,
-  findSecret as findSecret2,
-  HttpJudgeClient,
-  JUDGE_PROMPT_VERSION,
-  judgeBoundary,
-  LIMITS,
-  mergeVerdicts,
-  newId as newId2,
-  newJudgeStats,
-  one,
-  RelayError as RelayError3,
-  runJudge,
-  sha256Hex,
-  VerdictCache
-} from "@scp-dev/core";
-var HELD_PER_SENDER = 100;
-var iso = (ms) => ms === null ? null : new Date(ms).toISOString();
-var JudgeGate = class {
-  constructor(o) {
-    this.o = o;
-    o.sql.all(
-      `CREATE TABLE IF NOT EXISTS judge_holds (id TEXT PRIMARY KEY, from_ep TEXT NOT NULL, params TEXT NOT NULL, origin TEXT NOT NULL, verdict TEXT NOT NULL,
-       created_at INTEGER NOT NULL, expires_at INTEGER NOT NULL, state TEXT NOT NULL, by TEXT, resolved_at INTEGER)`
-    );
-    o.sql.all(
-      `CREATE TABLE IF NOT EXISTS judge_sent (from_ep TEXT NOT NULL, client_id TEXT NOT NULL, fingerprint TEXT NOT NULL, result TEXT NOT NULL, created_at INTEGER NOT NULL,
-       PRIMARY KEY (from_ep, client_id))`
-    );
-    o.sql.all(`UPDATE judge_holds SET state = 'held' WHERE state = 'releasing'`);
-  }
-  o;
-  stats = newJudgeStats();
-  policy;
-  version = "";
-  client = null;
-  cache = new VerdictCache();
-  shadows = /* @__PURE__ */ new Set();
-  /** judged sends in the last hour per budget: `ep:<id>`, `tree:<root id>` and `*` for the whole broker */
-  spent = /* @__PURE__ */ new Map();
-  /** the policy's judge section; a model client only when its key is readable, else the prefilter alone */
-  configure(policy) {
-    this.policy = policy;
-    this.version = policy ? sha256Hex(JSON.stringify(policy)) : "";
-    this.client = null;
-    const model = policy?.model;
-    if (!policy || policy.mode === "off" || !model) return;
-    const key = this.keyReader(model);
-    if (!key) {
-      this.o.log(
-        `relay broker: the judge model's key (${model.key_env ? `key_env ${model.key_env}` : `key_file ${model.key_file}`}) is not readable; judging with the prefilter only`
-      );
-      return;
-    }
-    this.client = (this.o.client ?? ((m, k) => new HttpJudgeClient({ model: m.id, effort: m.effort, key: k })))(model, key);
-  }
-  keyReader(model) {
-    if (model.key_env) {
-      const name = model.key_env;
-      return this.o.env[name] ? async () => this.o.env[name] ?? "" : null;
-    }
-    const file = model.key_file;
-    try {
-      accessSync(file, constants.R_OK);
-    } catch {
-      return null;
-    }
-    return async () => readFileSync4(file, "utf8").trim();
-  }
-  /** resolves once every shadow judgement started so far finished */
-  async settled() {
-    await Promise.all([...this.shadows]);
-  }
-  /** a send or ask through the judge; an unjudged one goes straight to `deliver` */
-  async send(from, params, origin, deliver) {
-    const policy = this.policy;
-    const body = params.body;
-    if (!policy || policy.mode === "off" || typeof body !== "string" || new TextEncoder().encode(body).length > LIMITS.bodyBytes || findSecret2(body))
-      return deliver(from, params, origin);
-    const targets = Array.isArray(params.to) ? params.to : [params.to];
-    if (targets.some((to) => this.o.core.foreignAccount(to) !== null)) {
-      if (policy.mode === "enforce") {
-        this.o.core.auditJudge("judge_skipped", from, null, {
-          side: "local",
-          boundary: "other account",
-          prompt_version: JUDGE_PROMPT_VERSION,
-          categories: [],
-          sha256: sha256Hex(body),
-          verdict: "skipped",
-          reason: "other_account_judged_by_hub",
-          to: targets.map(String)
-        });
-      }
-      return deliver(from, params, origin);
-    }
-    if (policy.mode === "shadow") {
-      const result = await deliver(from, params, origin);
-      if (!result.duplicate) this.shadow(policy, from, params, origin, result.id);
-      return result;
-    }
-    const { groups, tree } = this.boundaries(policy, from, params, origin);
-    if (!groups.size) return deliver(from, params, origin);
-    const ttl = params.ttl_s ?? LIMITS.ttlDefaultS;
-    if (!Number.isInteger(ttl) || ttl < 1 || ttl > LIMITS.ttlMaxS) throw new RelayError3("invalid_params", `ttl_s must be 1 to ${LIMITS.ttlMaxS}`);
-    const seen = params.client_id === void 0 ? void 0 : this.seen(from, params);
-    if (seen) return seen;
-    const waiting = one(this.o.sql, `SELECT COUNT(*) AS n FROM judge_holds WHERE from_ep = ? AND state IN ('held', 'releasing')`, from).n;
-    if (waiting >= HELD_PER_SENDER)
-      throw new RelayError3("rate_limited", `${waiting} of your messages wait for review by your human; send more once they released or refused some`, 3600);
-    this.spend(policy, from, tree);
-    const verdict = await this.judge(policy, from, body, groups);
-    const detail = this.detail(verdict, body, groups);
-    switch (verdict.verdict) {
-      case "refuse":
-        this.o.core.auditJudge("judge_refuse", from, null, detail);
-        throw new RelayError3(
-          "judge_refused",
-          `the relay judge refused this message (local; ${verdict.categories.join(", ") || "no category"}): ${verdict.reason}`,
-          void 0,
-          {
-            side: "local",
-            categories: verdict.categories,
-            reason: verdict.reason
-          }
-        );
-      case "hold":
-        return this.hold(from, params, origin, verdict, groups, detail);
-      case "redact": {
-        const applied = applyRedactions(body, verdict.redactions);
-        const result = await deliver(from, { ...params, body: applied.text }, origin);
-        const redacted = { n: applied.n, kinds: applied.kinds };
-        this.o.core.auditJudge(verdict.source === "error" ? "judge_skipped" : "judge_redact", from, result.id, { ...detail, redacted });
-        return this.remember(from, params, { ...result, redacted });
-      }
-      case "pass": {
-        const result = await deliver(from, params, origin);
-        if (verdict.source === "error") this.o.core.auditJudge("judge_skipped", from, result.id, detail);
-        return this.remember(from, params, result);
-      }
-    }
-  }
-  /** an earlier judged send or waiting hold under the send's client_id: the same message is answered as before, another one refused as core refuses it */
-  seen(from, params) {
-    const clientId = params.client_id;
-    const held2 = one(
-      this.o.sql,
-      `SELECT id, params FROM judge_holds WHERE from_ep = ? AND json_extract(params, '$.client_id') = ? AND state IN ('held', 'releasing')`,
-      from,
-      clientId
-    );
-    const sent = held2 ? void 0 : one(
-      this.o.sql,
-      `SELECT fingerprint, result FROM judge_sent WHERE from_ep = ? AND client_id = ? AND created_at > ?`,
-      from,
-      clientId,
-      this.o.now() - LIMITS.idempotencyS * 1e3
-    );
-    const before = held2 ? fingerprint(JSON.parse(held2.params)) : sent?.fingerprint;
-    if (before === void 0) return void 0;
-    if (before !== fingerprint(params)) throw new RelayError3("invalid_params", `client_id ${clientId} was already used for a different message`);
-    return held2 ? heldResult(held2.id, params) : { ...JSON.parse(sent.result), duplicate: true };
-  }
-  remember(from, params, result) {
-    if (params.client_id !== void 0 && !result.duplicate) {
-      this.o.sql.all(
-        `INSERT OR REPLACE INTO judge_sent (from_ep, client_id, fingerprint, result, created_at) VALUES (?, ?, ?, ?, ?)`,
-        from,
-        params.client_id,
-        fingerprint(params),
-        JSON.stringify(result),
-        this.o.now()
-      );
-    }
-    return result;
-  }
-  /**
-   * a judged send counts before any model call against its sender's, its lineage tree's and the whole broker's budget, since refused and
-   * held sends never reach the send's own limits, and a new handle or a helper process must not bring a fresh budget
-   */
-  spend(policy, from, tree) {
-    const now = this.o.now();
-    const global = policy.budget ?? DEFAULT_JUDGE_BUDGET;
-    const budgets = [
-      [`ep:${from}`, LIMITS.pairPerMinute, LIMITS.pairPerHour, "from this endpoint"],
-      [`tree:${tree}`, LIMITS.pairPerMinute * 2, LIMITS.pairPerHour * 2, "from this lineage tree"],
-      ["*", global.per_minute, global.per_hour, "on this broker"]
-    ];
-    const recent = budgets.map(([key]) => (this.spent.get(key) ?? []).filter((at) => at > now - 36e5));
-    budgets.forEach(([key, perMinute, perHour, what], i) => {
-      for (const [limit, windowS] of [
-        [perMinute, 60],
-        [perHour, 3600]
-      ]) {
-        const inWindow = recent[i].filter((at) => at > now - windowS * 1e3);
-        if (inWindow.length >= limit) {
-          this.spent.set(key, recent[i]);
-          throw new RelayError3(
-            "rate_limited",
-            `${limit} judged messages ${what} in ${windowS} s`,
-            Math.max(1, Math.ceil((inWindow[0] + windowS * 1e3 - now) / 1e3))
-          );
-        }
-      }
-    });
-    for (const [i, [key]] of budgets.entries()) this.spent.set(key, [...recent[i], now]);
-  }
-  /** how many budgets are tracked (idle ones are evicted by the sweep) */
-  budgetKeys() {
-    return this.spent.size;
-  }
-  /** the held messages, newest first, without bodies */
-  holds(state) {
-    const rows = state ? this.o.sql.all(`SELECT * FROM judge_holds WHERE state = ? ORDER BY created_at DESC, rowid DESC LIMIT 200`, state) : this.o.sql.all(`SELECT * FROM judge_holds ORDER BY created_at DESC, rowid DESC LIMIT 200`);
-    return rows.map((row) => this.view(row));
-  }
-  /** one hold with its body and the judge's redactions while it waits */
-  show(id) {
-    const row = this.row(id);
-    const params = JSON.parse(row.params);
-    const verdict = JSON.parse(row.verdict);
-    return { ...this.view(row), ...typeof params.body === "string" ? { body: params.body } : {}, redactions: verdict.redactions };
-  }
-  /** delivers a held message as its sender, as stored or redacted: scope, policy and limits are checked again by the send itself */
-  async release(id, options, deliver) {
-    const row = one(
-      this.o.sql,
-      `UPDATE judge_holds SET state = 'releasing' WHERE id = ? AND state = 'held' AND expires_at > ? RETURNING *`,
-      id,
-      this.o.now()
-    );
-    if (!row) throw new RelayError3("not_found", `no held message ${id}`);
-    const params = JSON.parse(row.params);
-    const verdict = JSON.parse(row.verdict);
-    let sent = params;
-    let redacted;
-    if (options.redacted) {
-      const applied = applyRedactions(params.body, verdict.redactions);
-      if (!applied.n) {
-        this.o.sql.all(`UPDATE judge_holds SET state = 'held' WHERE id = ?`, id);
-        throw new RelayError3("invalid_params", `hold ${id} has no redactions: release it as it is or refuse it`);
-      }
-      sent = { ...params, body: applied.text };
-      redacted = { n: applied.n, kinds: applied.kinds };
-    }
-    let result;
-    try {
-      result = await deliver(row.from_ep, sent, JSON.parse(row.origin));
-    } catch (error) {
-      this.o.sql.all(`UPDATE judge_holds SET state = 'held' WHERE id = ?`, id);
-      throw error;
-    }
-    this.remember(row.from_ep, params, { ...result, ...redacted ? { redacted } : {} });
-    this.resolve(row, "released", options.by);
-    this.o.core.auditJudge("judge_override", row.from_ep, id, {
-      ...this.storedDetail(row, verdict),
-      by: options.by,
-      action: redacted ? "release_redacted" : "release",
-      ...redacted ? { redacted } : {}
-    });
-    this.tell(
-      row.from_ep,
-      `relay: your message held for review as ${id} was released by your human${redacted ? " with redactions" : ""} and delivered as ${result.id}`
-    );
-    return { ...result, ...redacted ? { redacted } : {} };
-  }
-  /** refuses a held message: it is never delivered, and its sender hears the human's reason */
-  refuse(id, reason, by) {
-    this.expire(this.o.now());
-    const row = one(this.o.sql, `SELECT * FROM judge_holds WHERE id = ? AND state = 'held'`, id);
-    if (!row) throw new RelayError3("not_found", `no held message ${id}`);
-    const verdict = JSON.parse(row.verdict);
-    this.resolve(row, "refused", by);
-    this.o.core.auditJudge("judge_override", row.from_ep, id, { ...this.storedDetail(row, verdict), by, action: "refuse", reason });
-    this.tell(row.from_ep, `relay: your message held for review as ${id} was refused by your human: ${reason}`);
-    return this.view(this.row(id));
-  }
-  /** expires holds past their message TTL (body purged, sender told) and drops resolved ones past the audit window */
-  sweep() {
-    const now = this.o.now();
-    this.expire(now);
-    this.o.sql.all(`DELETE FROM judge_holds WHERE state IN ('released', 'refused', 'expired') AND resolved_at <= ?`, now - LIMITS.auditKeepS * 1e3);
-    this.o.sql.all(`DELETE FROM judge_sent WHERE created_at <= ?`, now - LIMITS.idempotencyS * 1e3);
-    for (const [key, times] of this.spent) if (!times.length || times[times.length - 1] <= now - 36e5) this.spent.delete(key);
-  }
-  expire(now) {
-    for (const row of this.o.sql.all(`SELECT * FROM judge_holds WHERE state = 'held' AND expires_at <= ?`, now)) {
-      const verdict = JSON.parse(row.verdict);
-      this.resolve(row, "expired", null);
-      this.o.core.auditJudge("judge_expire", row.from_ep, row.id, this.storedDetail(row, verdict));
-      this.tell(row.from_ep, `relay: your message held for review as ${row.id} expired without review and was not delivered`);
-    }
-  }
-  /** the recipients by the boundary their message crosses; throws as send does for a target the sender cannot reach */
-  boundaries(policy, from, params, origin) {
-    const { sender, recipients, tree } = this.o.core.judgeSubjects(from, params, origin);
-    const groups = /* @__PURE__ */ new Map();
-    for (const recipient of recipients) {
-      const label = judgeBoundary(policy, sender, recipient);
-      if (label !== null) groups.set(label, [...groups.get(label) ?? [], recipient.address]);
-    }
-    return { groups, tree };
-  }
-  async judge(policy, from, body, groups) {
-    const verdicts = await Promise.all(
-      [...groups].map(
-        ([boundary, to]) => runJudge({
-          body,
-          side: "local",
-          boundary,
-          configVersion: this.version,
-          client: this.client,
-          cache: this.cache,
-          timeoutMs: policy.timeout_s * 1e3,
-          failMode: policy.fail,
-          ...this.client && policy.model ? { model: policy.model.id } : {},
-          from: this.o.core.addressOf(from),
-          to,
-          now: this.o.now,
-          stats: this.stats
-        })
-      )
-    );
-    return mergeVerdicts(verdicts);
-  }
-  shadow(policy, from, params, origin, ref) {
-    const task = (async () => {
-      try {
-        const { groups, tree } = this.boundaries(policy, from, params, origin);
-        if (!groups.size) return;
-        this.spend(policy, from, tree);
-        const body = params.body;
-        const verdict = await this.judge(policy, from, body, groups);
-        this.o.core.auditJudge("judge_shadow", from, ref, this.detail(verdict, body, groups));
-      } catch (error) {
-        this.o.log(`relay broker: a shadow judgement failed: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    })();
-    this.shadows.add(task);
-    void task.finally(() => this.shadows.delete(task));
-  }
-  hold(from, params, origin, verdict, groups, detail) {
-    const now = this.o.now();
-    const id = newId2("hold", now);
-    const stored = { ...params, client_id: params.client_id ?? id };
-    const to = [...groups.values()].flat();
-    const record = { ...verdict, boundary: [...groups.keys()].join(" | "), to };
-    this.o.sql.all(
-      `INSERT INTO judge_holds (id, from_ep, params, origin, verdict, created_at, expires_at, state) VALUES (?, ?, ?, ?, ?, ?, ?, 'held')`,
-      id,
-      from,
-      JSON.stringify(stored),
-      JSON.stringify(origin),
-      JSON.stringify(record),
-      now,
-      now + (params.ttl_s ?? LIMITS.ttlDefaultS) * 1e3
-    );
-    this.o.core.auditJudge("judge_hold", from, id, detail);
-    return heldResult(id, params);
-  }
-  detail(verdict, body, groups) {
-    return {
-      side: "local",
-      boundary: [...groups.keys()].join(" | "),
-      prompt_version: verdict.prompt_version,
-      categories: verdict.categories,
-      sha256: sha256Hex(body),
-      verdict: verdict.verdict,
-      source: verdict.source,
-      reason: verdict.reason,
-      to: [...groups.values()].flat(),
-      ...verdict.model ? { model: verdict.model } : {},
-      ...verdict.ms !== void 0 ? { ms: verdict.ms } : {}
-    };
-  }
-  storedDetail(row, verdict) {
-    const params = JSON.parse(row.params);
-    return {
-      side: "local",
-      boundary: verdict.boundary,
-      prompt_version: verdict.prompt_version,
-      categories: verdict.categories,
-      sha256: params.sha256 ?? sha256Hex(params.body ?? ""),
-      verdict: verdict.verdict,
-      to: verdict.to,
-      ...verdict.model ? { model: verdict.model } : {}
-    };
-  }
-  /** marks a hold resolved and purges its body and the judge's quotes of it */
-  resolve(row, state, by) {
-    const { body, ...params } = JSON.parse(row.params);
-    const verdict = JSON.parse(row.verdict);
-    const purged = { ...params, bytes: new TextEncoder().encode(body).length, sha256: sha256Hex(body) };
-    const kinds = { ...verdict, redactions: verdict.redactions.map((r) => ({ kind: r.kind })) };
-    this.o.sql.all(
-      `UPDATE judge_holds SET state = ?, by = ?, resolved_at = ?, params = ?, verdict = ? WHERE id = ?`,
-      state,
-      by,
-      this.o.now(),
-      JSON.stringify(purged),
-      JSON.stringify(kinds),
-      row.id
-    );
-  }
-  tell(endpoint, text) {
-    try {
-      this.o.core.judgeNotice(endpoint, text);
-      this.o.wake(endpoint);
-    } catch (error) {
-      if (!(error instanceof RelayError3)) throw error;
-    }
-  }
-  row(id) {
-    const row = one(this.o.sql, `SELECT * FROM judge_holds WHERE id = ?`, id);
-    if (!row) throw new RelayError3("not_found", `no held message ${id}`);
-    return row;
+import { JudgeGate as HubJudgeGate } from "@scp-dev/hub";
+function readKeyFile(file) {
+  try {
+    accessSync(file, constants.R_OK);
+  } catch {
+    return null;
   }
-  view(row) {
-    const params = JSON.parse(row.params);
-    const verdict = JSON.parse(row.verdict);
-    return {
-      id: row.id,
-      from: this.o.core.addressOf(row.from_ep),
-      to: verdict.to,
-      state: row.state,
-      created_at: iso(row.created_at),
-      expires_at: iso(row.expires_at),
-      categories: verdict.categories,
-      reason: verdict.reason,
-      boundary: verdict.boundary,
-      source: verdict.source,
-      bytes: params.bytes ?? new TextEncoder().encode(params.body ?? "").length,
-      by: row.by,
-      resolved_at: iso(row.resolved_at)
-    };
+  return async () => readFileSync4(file, "utf8").trim();
+}
+var JudgeGate = class extends HubJudgeGate {
+  constructor(options) {
+    super({ keyFile: readKeyFile, ...options });
   }
 };
-var fingerprint = (p) => sha256Hex(
-  JSON.stringify([
-    [p.to].flat().map(String).sort(),
-    p.body,
-    p.kind ?? "message",
-    p.thread ?? null,
-    p.reply_to ?? null,
-    p.data_class ?? "public",
-    (p.attachments ?? []).map((a) => a?.path).sort(),
-    p.mime ?? null,
-    p.ttl_s ?? LIMITS.ttlDefaultS,
-    p.require_reply ?? null
-  ])
-);
-function heldResult(id, params) {
-  return { id, thread: params.thread ?? "", hop: 0, deliveries: [], held: { hold_id: id, side: "local" } };
-}
 
 // src/sessions.ts
 import { createHash as createHash2, randomUUID } from "crypto";
@@ -1773,21 +1333,17 @@ async function startBroker(options) {
     }
     for (const id of known.keys()) if (!live.has(id)) known.delete(id);
   }, options.presenceEveryMs ?? PRESENCE_MS);
-  if (options.bridge) {
-    bridge = startBridge({
-      ...options.bridge,
-      core,
-      onRemote: {
-        wake,
-        fleet: notifyFleet,
-        policyError: () => {
-          loadPolicy();
-          return policyError;
-        },
-        log
-      }
-    });
-  }
+  const remoteHooks = {
+    wake,
+    fleet: notifyFleet,
+    policyError: () => {
+      loadPolicy();
+      return policyError;
+    },
+    log
+  };
+  if (options.bridge) bridge = startBridge({ ...options.bridge, core, onRemote: remoteHooks });
+  else if (options.link) bridge = options.link({ core, hooks: remoteHooks, send: (from, params, origin) => judge.send(from, params, origin, deliver) });
   async function relink() {
     const config = options.bridgeConfig ? await options.bridgeConfig() : options.bridge;
     if (!config || bridge && config.url === options.bridge?.url && config.machine === options.bridge?.machine) {
@@ -1943,7 +1499,7 @@ async function startBroker(options) {
       endpoint: core.whoami(endpoint),
       capabilities: BROKER_CAPABILITIES,
       server_time: (/* @__PURE__ */ new Date()).toISOString(),
-      limits: LIMITS2,
+      limits: LIMITS,
       preamble: PREAMBLE,
       broker: brokerInfo()
     };
@@ -1973,16 +1529,16 @@ async function startBroker(options) {
   }
   async function gather(me, result, peek, s) {
     const gathering = (r) => workerResults(r) > 0 && !r.more && !r.prompted && othersRunning(r) > 0;
-    const cap = Date.now() + LIMITS2.pushGraceS * 1e3;
-    let quiet = Date.now() + LIMITS2.pushQuietS * 1e3;
+    const cap = Date.now() + LIMITS.pushGraceS * 1e3;
+    let quiet = Date.now() + LIMITS.pushQuietS * 1e3;
     let results = workerResults(result);
     while (gathering(result) && !s.data.closed && Date.now() < Math.min(quiet, cap)) {
       await waitFor(me, Math.min(quiet, cap) - Date.now(), s);
-      if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+      if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
       result = core.stopWait(me, peek);
       if (workerResults(result) > results) {
         results = workerResults(result);
-        quiet = Date.now() + LIMITS2.pushQuietS * 1e3;
+        quiet = Date.now() + LIMITS.pushQuietS * 1e3;
       }
     }
   }
@@ -2076,7 +1632,7 @@ async function startBroker(options) {
       if (hasId) write(s, { jsonrpc: "2.0", id, result });
     } catch (error) {
       if (!hasId || closing) return;
-      if (error instanceof RelayError4) {
+      if (error instanceof RelayError3) {
         const code = error.code === "method_not_found" ? -32601 : error.code === "invalid_params" ? -32602 : -32e3;
         write(s, {
           jsonrpc: "2.0",
@@ -2097,64 +1653,70 @@ async function startBroker(options) {
     }
   }
   function endpointOf(s) {
-    if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+    if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
     if (!s.data.endpoint)
-      throw new RelayError4("unauthorized", s.data.observer ? "this connection only observes: say hello as an agent or the human" : "call hello first");
+      throw new RelayError3("unauthorized", s.data.observer ? "this connection only observes: say hello as an agent or the human" : "call hello first");
     core.touch(s.data.endpoint);
     return s.data.endpoint;
   }
   function waitSeconds(value) {
     if (value === void 0) return 0;
-    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new RelayError4("invalid_params", "wait_s must be a number of seconds");
-    return Math.min(value, LIMITS2.waitMaxS) * 1e3;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw new RelayError3("invalid_params", "wait_s must be a number of seconds");
+    return Math.min(value, LIMITS.waitMaxS) * 1e3;
   }
   function checkAttachments(attachments, s) {
     if (attachments === void 0) return void 0;
-    if (!Array.isArray(attachments)) throw new RelayError4("invalid_params", "attachments must be a list");
+    if (!Array.isArray(attachments)) throw new RelayError3("invalid_params", "attachments must be a list");
     const tooWide = /* @__PURE__ */ new Set(["/", realOrSelf(homedir2()), realOrSelf(accountHome())]);
     const roots = [s.data.cwd, ...options.roots ?? []].filter((r) => typeof r === "string" && isAbsolute(r)).map(realOrSelf).filter((r) => !tooWide.has(r));
     return attachments.map((attachment) => {
       if (attachment?.kind !== "path" || typeof attachment.path !== "string" || !isAbsolute(attachment.path)) {
-        throw new RelayError4("invalid_params", "an attachment is {kind: path, path: an absolute path}");
+        throw new RelayError3("invalid_params", "an attachment is {kind: path, path: an absolute path}");
       }
       let real;
       try {
         real = realpathSync(attachment.path);
       } catch {
-        throw new RelayError4("not_found", `no file at ${attachment.path}`);
+        throw new RelayError3("not_found", `no file at ${attachment.path}`);
       }
       if (!roots.some((root) => real === root || real.startsWith(root.endsWith(sep) ? root : root + sep))) {
-        throw new RelayError4("invalid_params", `${attachment.path} is outside the sender's working directory and the relay's allowed roots`);
+        throw new RelayError3("invalid_params", `${attachment.path} is outside the sender's working directory and the relay's allowed roots`);
       }
       return { kind: "path", path: real };
     });
   }
   async function dispatch(s, method, params) {
     if (method === "hello") {
-      if (s.data.endpoint || s.data.observer) throw new RelayError4("invalid_params", "hello was already called on this connection");
-      if (params.protocol !== PROTOCOL3) throw new RelayError4("invalid_params", `this broker speaks ${PROTOCOL3}`);
+      if (s.data.endpoint || s.data.observer) throw new RelayError3("invalid_params", "hello was already called on this connection");
+      if (params.protocol !== PROTOCOL3) throw new RelayError3("invalid_params", `this broker speaks ${PROTOCOL3}`);
       if (params.transient === true) {
         if (params.human === true || params.observe === true || params.resume !== void 0) {
-          throw new RelayError4("invalid_params", "a hook connection claims an agent endpoint: transient does not go with human, observe or resume");
+          throw new RelayError3("invalid_params", "a hook connection claims an agent endpoint: transient does not go with human, observe or resume");
         }
         const join5 = params.join;
         if (join5 !== void 0 && (typeof join5 !== "object" || join5 === null || Array.isArray(join5)))
-          throw new RelayError4("invalid_params", "join is {handle?}");
+          throw new RelayError3("invalid_params", "join is {handle?, under?}");
+        const under = join5?.under;
         const before2 = new Map(core.list({ all: true }).map((view) => [view.id, view]));
-        const { endpoint: endpoint2, subagent, created } = join5 === void 0 ? core.claim(params.claim ?? {}, { transient: true }) : { endpoint: core.joinSession(params.claim ?? {}, join5.handle), subagent: void 0, created: void 0 };
+        const { endpoint: endpoint2, subagent, created } = join5 === void 0 ? core.claim(params.claim ?? {}, { transient: true }) : {
+          endpoint: core.joinSession(params.claim ?? {}, join5.handle, under),
+          subagent: void 0,
+          created: void 0
+        };
         s.data.endpoint = endpoint2.id;
         s.data.transient = true;
         const key = params.claim?.process;
         if (typeof key === "string") s.data.process = key;
         const was2 = before2.get(endpoint2.id)?.address;
         if (join5 !== void 0) membership(endpoint2, core.sessionOf(endpoint2.id), true, was2?.slice(was2.lastIndexOf("/") + 1));
+        if (under !== void 0 && before2.get(endpoint2.id)?.parent !== endpoint2.parent) bridge?.resync();
         else if ((before2.get(endpoint2.id)?.presence ?? "offline") !== endpoint2.presence) presenceChanged(endpoint2);
         return {
           endpoint: endpoint2,
           ...subagent ? { subagent, ...created ? { created } : {} } : {},
           capabilities: BROKER_CAPABILITIES,
           server_time: (/* @__PURE__ */ new Date()).toISOString(),
-          limits: LIMITS2,
+          limits: LIMITS,
           preamble: PREAMBLE,
           broker: brokerInfo()
         };
@@ -2162,7 +1724,7 @@ async function startBroker(options) {
       if (params.observe === true) {
         const self = params.self === void 0 ? null : core.placeLineage(params.self);
         if (params.grant !== void 0) {
-          if (!core.grantBinds(params.grant, self)) throw new RelayError4("unauthorized", GRANT_UNBOUND);
+          if (!core.grantBinds(params.grant, self)) throw new RelayError3("unauthorized", GRANT_UNBOUND);
           return { ...bindLineage(s, self, params, true), grant_bound: true };
         }
         if (self) return bindLineage(s, self, params, true);
@@ -2172,7 +1734,7 @@ async function startBroker(options) {
           endpoint: null,
           capabilities: BROKER_CAPABILITIES,
           server_time: (/* @__PURE__ */ new Date()).toISOString(),
-          limits: LIMITS2,
+          limits: LIMITS,
           preamble: PREAMBLE,
           broker: brokerInfo()
         };
@@ -2180,7 +1742,10 @@ async function startBroker(options) {
       const claim = params.claim;
       if (params.human === true && params.resume === void 0 && params.lineage !== void 0) {
         const placed = core.placeLineage(params.lineage);
-        if (placed) return bindLineage(s, placed, params);
+        if (placed) {
+          s.data.terminal = params.tty === true;
+          return bindLineage(s, placed, params);
+        }
       } else if (params.human !== true && params.resume === void 0 && claim?.process === void 0 && typeof claim?.handle === "string") {
         const placed = claim.lineage === void 0 ? null : core.placeLineage(claim.lineage, claim.handle);
         if (placed && (claim.grant === void 0 || core.grantBinds(claim.grant, placed))) {
@@ -2215,17 +1780,17 @@ async function startBroker(options) {
         ...token ? { token } : {},
         capabilities: BROKER_CAPABILITIES,
         server_time: (/* @__PURE__ */ new Date()).toISOString(),
-        limits: LIMITS2,
+        limits: LIMITS,
         preamble: PREAMBLE,
         broker: brokerInfo()
       };
     }
-    if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+    if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
     if (s.data.observer && OBSERVER_METHODS.has(method)) return observe(s, method, params);
     if (s.data.observer && SCOPE_METHODS.has(method) && (s.data.lineage || method === "why")) return scope(s, method, params);
-    if (s.data.transient && SCOPE_METHODS.has(method)) throw new RelayError4("scope_refused", "a hook connection cannot read or change scopes, groups or grants");
+    if (s.data.transient && SCOPE_METHODS.has(method)) throw new RelayError3("scope_refused", "a hook connection cannot read or change scopes, groups or grants");
     const me = endpointOf(s);
-    if (s.data.transient && !TRANSIENT_METHODS.has(method)) throw new RelayError4("unauthorized", "a hook connection only posts activity and status");
+    if (s.data.transient && !TRANSIENT_METHODS.has(method)) throw new RelayError3("unauthorized", "a hook connection only posts activity and status");
     if (OBSERVER_METHODS.has(method)) return observe(s, method, params);
     if (SCOPE_METHODS.has(method)) return scope(s, method, params);
     switch (method) {
@@ -2233,13 +1798,13 @@ async function startBroker(options) {
         return s.data.transient ? core.whoami(me) : { ...core.whoami(me), ...core.peekState(me) };
       case "peek_turn":
         if (!s.data.transient || !core.hookOwns(me, s.data.process))
-          throw new RelayError4("unauthorized", "only a hook of the endpoint's own harness process posts digest turns");
+          throw new RelayError3("unauthorized", "only a hook of the endpoint's own harness process posts digest turns");
         return core.peekTurn(me, { role: params.role, text: params.text });
       case "send":
       case "ask": {
-        for (const field of SERVER_FIELDS) if (field in params) throw new RelayError4("invalid_params", `${field} is set by the relay, not the sender`);
+        for (const field of SERVER_FIELDS) if (field in params) throw new RelayError3("invalid_params", `${field} is set by the relay, not the sender`);
         loadPolicy();
-        if (policyError) throw new RelayError4("policy_refused", policyError);
+        if (policyError) throw new RelayError3("policy_refused", policyError);
         const attachments = checkAttachments(params.attachments, s);
         const send = { ...params, ...attachments ? { attachments } : {} };
         if (method === "ask") send.kind = "request";
@@ -2255,16 +1820,16 @@ async function startBroker(options) {
       case "hold_release": {
         const id = required(reviewer(s, params), "id");
         loadPolicy();
-        if (policyError) throw new RelayError4("policy_refused", policyError);
+        if (policyError) throw new RelayError3("policy_refused", policyError);
         return judge.release(id, { redacted: params.redacted === true, by: core.addressOf(me) }, deliver);
       }
       case "hold_refuse": {
         const reason = required(reviewer(s, params), "reason");
-        if (reason.length > LIMITS2.noteChars) throw new RelayError4("invalid_params", `reason takes at most ${LIMITS2.noteChars} characters`);
+        if (reason.length > LIMITS.noteChars) throw new RelayError3("invalid_params", `reason takes at most ${LIMITS.noteChars} characters`);
         return judge.refuse(required(params, "id"), stripControl(reason), core.addressOf(me));
       }
       case "ask_wait": {
-        if (typeof params.id !== "string") throw new RelayError4("invalid_params", "id is the request's message id");
+        if (typeof params.id !== "string") throw new RelayError3("invalid_params", "id is the request's message id");
         return awaitReply(s, me, params.id, waitSeconds(params.wait_s));
       }
       case "inbox": {
@@ -2274,7 +1839,7 @@ async function startBroker(options) {
         let page = read();
         while (!page.messages.length && !s.data.closed && Date.now() < deadline) {
           await waitFor(me, deadline - Date.now(), s);
-          if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+          if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
           page = read();
         }
         const { messages } = page;
@@ -2297,6 +1862,21 @@ async function startBroker(options) {
         membership(renamed.endpoint, renamed.session, true, renamed.from);
         return renamed.endpoint;
       }
+      case "adopt": {
+        const actor = actorOf(s);
+        const adopted = core.adopt(
+          actor,
+          { endpoint: params.endpoint, ...params.parent !== void 0 ? { parent: params.parent } : {} },
+          { tty: actor.kind === "endpoint" && s.data.terminal === true }
+        );
+        bridge?.resync();
+        return adopted;
+      }
+      case "unlink": {
+        const unlinked = core.unlink(actorOf(s), params.endpoint !== void 0 ? { endpoint: params.endpoint } : {});
+        bridge?.resync();
+        return unlinked;
+      }
       case "leave": {
         const left = core.leaveSession(actorOf(s), params.endpoint !== void 0 ? { endpoint: params.endpoint } : {});
         for (const c of connections) if (c.data.endpoint === left.endpoint.id && !c.data.transient && !c.data.lineage && c !== s) c.end();
@@ -2332,7 +1912,7 @@ async function startBroker(options) {
         let result = core.inject(me, options2);
         while (!result.offered.length && !s.data.closed && Date.now() < deadline) {
           await waitFor(me, deadline - Date.now(), s);
-          if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+          if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
           result = core.inject(me, options2);
         }
         return result;
@@ -2346,7 +1926,7 @@ async function startBroker(options) {
         const idle = (r) => !r.messages.length && !r.more && r.workers.length + r.starting > 0 && r.pushes_left > 0 && !r.prompted;
         while (idle(result) && !s.data.closed && Date.now() < deadline) {
           await waitFor(me, Math.min(STOP_RECHECK_MS, deadline - Date.now()), s);
-          if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+          if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
           result = core.stopWait(me, peek);
         }
         if (waitMs > 0) await gather(me, result, peek, s);
@@ -2373,13 +1953,13 @@ async function startBroker(options) {
       case "receipts":
         return core.receipts(me, params.id);
     }
-    throw new RelayError4("method_not_found", `no method ${method}`);
+    throw new RelayError3("method_not_found", `no method ${method}`);
   }
   const deliver = async (from, send, origin) => {
     let result;
     if (remoteSend(core, send.to)) {
       if (!bridge)
-        throw new RelayError4("not_found", `no endpoint ${[send.to].flat().join(", ")}: this broker is not linked to a hub (${CLI_NAME} cloud enable)`);
+        throw new RelayError3("not_found", `no endpoint ${[send.to].flat().join(", ")}: this broker is not linked to a hub (${CLI_NAME} cloud enable)`);
       result = await bridge.forward(from, send, origin);
     } else {
       result = core.send(from, send, origin);
@@ -2399,7 +1979,7 @@ async function startBroker(options) {
     return result;
   };
   function reviewer(s, params) {
-    if (!atTerminal(s)) throw new RelayError4("unauthorized", "only your human at a terminal reviews held messages");
+    if (!atTerminal(s)) throw new RelayError3("unauthorized", "only your human at a terminal reviews held messages");
     return params;
   }
   function observe(s, method, params) {
@@ -2407,7 +1987,7 @@ async function startBroker(options) {
     switch (method) {
       case "list":
         if (params.contacts === true) {
-          if (!bridge) throw new RelayError4("unavailable", `this broker is not linked to a hub (${CLI_NAME} cloud enable), so it reaches no contacts`);
+          if (!bridge) throw new RelayError3("unavailable", `this broker is not linked to a hub (${CLI_NAME} cloud enable), so it reaches no contacts`);
           return bridge.contacts().then((contacts) => ({ contacts }));
         }
         return { endpoints: core.list({ ...params, viewer, peekable: viewer === void 0 }) };
@@ -2448,7 +2028,7 @@ async function startBroker(options) {
       case "bridge_relink":
         return relink();
     }
-    throw new RelayError4("method_not_found", `no method ${method}`);
+    throw new RelayError3("method_not_found", `no method ${method}`);
   }
   function scope(s, method, params) {
     const result = scopeCall(s, method, params);
@@ -2527,7 +2107,7 @@ async function startBroker(options) {
         return result;
       }
     }
-    throw new RelayError4("method_not_found", `no method ${method}`);
+    throw new RelayError3("method_not_found", `no method ${method}`);
   }
   function realOrSelf(path) {
     try {
@@ -2540,7 +2120,7 @@ async function startBroker(options) {
     const deadline = Date.now() + ms;
     const present = sent?.deliveries.filter((d) => !d.offline).map((d) => d.endpoint);
     for (; ; ) {
-      if (closing) throw new RelayError4("unauthorized", "the relay broker is stopping");
+      if (closing) throw new RelayError3("unauthorized", "the relay broker is stopping");
       const reply = core.replyTo(me, request);
       if (reply) {
         core.ack(me, [reply.seq]);
@@ -2592,18 +2172,18 @@ function compact(fields) {
 function optional(params, key) {
   const value = params[key];
   if (value === void 0 || value === null) return void 0;
-  if (typeof value !== "string") throw new RelayError4("invalid_params", `${key} must be a string`);
+  if (typeof value !== "string") throw new RelayError3("invalid_params", `${key} must be a string`);
   return value;
 }
 function required(params, key) {
   const value = optional(params, key);
-  if (!value) throw new RelayError4("invalid_params", `${key} is required`);
+  if (!value) throw new RelayError3("invalid_params", `${key} is required`);
   return value;
 }
 function selectors(params, key) {
   const value = params[key];
   if (value === void 0 || value === null) return void 0;
-  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) throw new RelayError4("invalid_params", `${key} must be a list of selectors`);
+  if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) throw new RelayError3("invalid_params", `${key} must be a list of selectors`);
   return value;
 }
 export {