@chipschat/hermes 1.0.7 → 1.0.8

package/dist/main.js

@@ -8,11 +8,11 @@ var __export = (target, all) => {
 };
 
 // src/main.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
 import { createServer as createServer2 } from "node:net";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname6, join as join12, resolve as resolve6 } from "node:path";
+import { dirname as dirname6, join as join13, resolve as resolve6 } from "node:path";
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -25555,7 +25555,7 @@ function fileStore(path) {
 
 // src/bridge.ts
 import { mkdirSync as mkdirSync5 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/context.ts
 import { spawn } from "node:child_process";
@@ -25578,7 +25578,7 @@ import { basename as basename3, dirname as dirname4, join as join6 } from "node:
 
 // src/home.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync5, readlinkSync, statSync } from "node:fs";
+import { appendFileSync, chmodSync as chmodSync3, existsSync as existsSync5, readFileSync as readFileSync5, readlinkSync, statSync } from "node:fs";
 import { homedir as homedir4 } from "node:os";
 import { join as join5, resolve as resolve2 } from "node:path";
 function hermesRoot(env = process.env) {
@@ -25605,6 +25605,14 @@ function envValue(home2, name2) {
   }
   return found;
 }
+function appendEnv(home2, name2, value) {
+  const path = join5(home2, ".env");
+  const text = readFileSync5(path, "utf8");
+  const mode = statSync(path).mode & 511;
+  appendFileSync(path, `${text === "" || text.endsWith("\n") ? "" : "\n"}${name2}=${value}
+`);
+  chmodSync3(path, mode);
+}
 function configText(home2) {
   const path = join5(home2, "config.yaml");
   try {
@@ -25839,13 +25847,9 @@ function fileOf(source2, name2) {
 }
 var byOrder = (a, b) => ORDER.indexOf(a.kind) - ORDER.indexOf(b.kind) || a.profile.localeCompare(b.profile);
 var Picture = class {
-  /** Each file by its path, and the agents that read it. */
-  readers = /* @__PURE__ */ new Map();
-  /** The shared files, each with its id and the name the set shows. */
-  shared = /* @__PURE__ */ new Map();
-  /** The agents and the files each reads, in page order. */
-  agents = /* @__PURE__ */ new Map();
-  constructor(readers, first, env = process.env) {
+  constructor(readers, first, env = process.env, ownProfiles = false) {
+    this.first = first;
+    this.ownProfiles = ownProfiles;
     const byProfile = /* @__PURE__ */ new Map();
     const sourcesFor = (profile) => {
       let sources = byProfile.get(profile.home);
@@ -25867,7 +25871,7 @@ var Picture = class {
     }
     const taken = /* @__PURE__ */ new Set();
     const ids2 = /* @__PURE__ */ new Set();
-    const sharing = [...this.readers.values()].filter(({ source: source2, agents }) => source2.kind === "project" || source2.profile === first?.name || agents.length > 1).sort((a, b) => (a.source.profile === first?.name ? 0 : 1) - (b.source.profile === first?.name ? 0 : 1) || byOrder(a.source, b.source));
+    const sharing = [...this.readers.values()].filter(({ source: source2, agents }) => source2.kind === "project" || this.forNewAgents(source2) || agents.length > 1).sort((a, b) => (a.source.profile === first?.name ? 0 : 1) - (b.source.profile === first?.name ? 0 : 1) || byOrder(a.source, b.source));
     for (const { source: source2 } of sharing) {
       const name2 = taken.has(source2.file) ? `${source2.file} (${source2.profile})` : source2.file;
       taken.add(name2);
@@ -25877,8 +25881,24 @@ var Picture = class {
       this.shared.set(source2.path, { id: id2, name: name2 });
     }
   }
+  first;
+  ownProfiles;
+  /** Each file by its path, and the agents that read it. */
+  readers = /* @__PURE__ */ new Map();
+  /** The shared files, each with its id and the name the set shows. */
+  shared = /* @__PURE__ */ new Map();
+  /** The agents and the files each reads, in page order. */
+  agents = /* @__PURE__ */ new Map();
+  /**
+   * Whether each new agent starts with this file or a copy of it: the first profile's files, or
+   * where each new agent gets a profile of its own, the first profile's SOUL.md and the project file.
+   */
+  forNewAgents(source2) {
+    if (source2.profile !== this.first?.name) return false;
+    return !this.ownProfiles || source2.kind === "soul" || source2.kind === "project";
+  }
   /** The harness's own set, as `PUT /v1/harnesses/:id/context` takes it. */
-  harnessCopy(first) {
+  harnessCopy() {
     const shown2 = [];
     const notShown = [];
     for (const [path, { id: id2, name: name2 }] of this.shared) {
@@ -25894,8 +25914,7 @@ var Picture = class {
         ...file3,
         id: id2,
         used_by: agents.length,
-        // A new agent runs on the first profile: it reads that profile's files and its project file.
-        ...source2.profile === first?.name ? { for_new_agents: true } : {}
+        ...this.forNewAgents(source2) ? { for_new_agents: true } : {}
       });
     }
     return {
@@ -26056,9 +26075,9 @@ var Contexts = class {
   /** Every copy read again, and sent where it moved. */
   refresh() {
     return this.inLine(async () => {
-      const { readers, first } = this.roster();
-      const picture = new Picture(readers, first, this.env);
-      await this.port.harness(picture.harnessCopy(first)).catch((error62) => {
+      const { readers, first, ownProfiles } = this.roster();
+      const picture = new Picture(readers, first, this.env, ownProfiles);
+      await this.port.harness(picture.harnessCopy()).catch((error62) => {
         this.log(`the harness's context not sent: ${messageOf(error62)}`);
       });
       for (const { agentId: agentId2 } of readers) {
@@ -26076,12 +26095,12 @@ var Contexts = class {
    */
   async edit(frame) {
     const answer = await this.inLine(async () => {
-      const { readers, first } = this.roster();
+      const { readers, first, ownProfiles } = this.roster();
       const copyNow = () => {
-        const picture = new Picture(readers, first, this.env);
-        return frame.agent_id === void 0 ? picture.harnessCopy(first) : picture.agentCopy(frame.agent_id);
+        const picture = new Picture(readers, first, this.env, ownProfiles);
+        return frame.agent_id === void 0 ? picture.harnessCopy() : picture.agentCopy(frame.agent_id);
       };
-      const found = new Picture(readers, first, this.env).find(frame.agent_id, frame.name);
+      const found = new Picture(readers, first, this.env, ownProfiles).find(frame.agent_id, frame.name);
       if (found === void 0) {
         throw new Refuse(`Hermes gives this agent no file called ${frame.name}.`, copyNow(), "failed");
       }
@@ -26148,6 +26167,8 @@ function numbersOf(profile, body) {
   if (typeof body !== "object" || body === null) return void 0;
   const top = body;
   if (top["hook_event_name"] !== "post_api_request") return void 0;
+  const sender = top["profile"];
+  if (typeof sender === "string" && sender !== profile && sender !== "custom") return void 0;
   const extra = typeof top["extra"] === "object" && top["extra"] !== null ? top["extra"] : {};
   const named = typeof top["session_id"] === "string" ? top["session_id"] : "";
   const task2 = typeof extra["task_id"] === "string" && extra["task_id"] !== "" ? extra["task_id"] : void 0;
@@ -26453,6 +26474,13 @@ var HermesClient = class {
     const latest = read["session_id"];
     return typeof latest === "string" && latest !== "" ? latest : sessionId;
   }
+  /**
+   * The models Hermes has for this profile, as its own picker lists them: `GET /api/model/options`,
+   * only the providers the profile is set up for (`models.ts`).
+   */
+  async modelOptions() {
+    return await this.call("GET", "/api/model/options?include_unconfigured=false");
+  }
   /** A run in a session: what it is told, and under a key a retry of the same turn repeats. */
   async startRun(input2) {
     const started = await this.call(
@@ -26462,6 +26490,7 @@ var HermesClient = class {
         input: input2.text,
         session_id: input2.sessionId,
         ...input2.model === void 0 ? {} : { model: input2.model },
+        ...input2.provider === void 0 ? {} : { provider: input2.provider },
         ...input2.instructions === void 0 ? {} : { instructions: input2.instructions }
       },
       { "Idempotency-Key": input2.key.slice(0, 255) }
@@ -26558,7 +26587,7 @@ async function failureOf(answer) {
 }
 
 // src/hooks.ts
-import { appendFileSync, chmodSync as chmodSync3, existsSync as existsSync7, readFileSync as readFileSync7, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join7 } from "node:path";
 var HOOK_NAME = "chips";
 var SECRET_ENV = "CHIPS_HOOK_SECRET";
@@ -26595,12 +26624,7 @@ function entryLines(indent, url2, secret) {
 function secretInEnv(home2, secret) {
   const path = join7(home2, ".env");
   if (!existsSync7(path)) return false;
-  if (envValue(home2, SECRET_ENV) !== void 0) return true;
-  const text = readFileSync7(path, "utf8");
-  const mode = statSync3(path).mode & 511;
-  appendFileSync(path, `${text === "" || text.endsWith("\n") ? "" : "\n"}${SECRET_ENV}=${secret}
-`);
-  chmodSync3(path, mode);
+  if (envValue(home2, SECRET_ENV) === void 0) appendEnv(home2, SECRET_ENV, secret);
   return true;
 }
 function addHook(home2, port, profile, secret) {
@@ -26661,1417 +26685,1804 @@ function addHook(home2, port, profile, secret) {
   return { state: "added", path };
 }
 
-// src/bridge.ts
-var WANTS = ["agents", "new_agents", "forks", "context_files", "context_windows", "restarts"];
-function settingsFor(active) {
-  const bridge2 = () => {
-    const there = active();
-    if (there === void 0) throw new Refuse("The bridge is starting. Try again in a moment.");
-    return there;
-  };
+// src/models.ts
+var MODEL_CHOICES_MAX2 = 40;
+var LABEL_MAX = 80;
+var DEFAULT_LABEL = "Hermes's default";
+function choiceId(provider, model) {
+  return `${provider}/${model}`;
+}
+function runModelOf(id2) {
+  const at = id2.indexOf("/");
+  return at <= 0 ? { model: id2 } : { provider: id2.slice(0, at), model: id2.slice(at + 1) };
+}
+function providersOf(options) {
+  const ready = (options.providers ?? []).filter(
+    (provider) => provider.authenticated !== false && (provider.models ?? []).length > 0
+  );
+  const current = (provider) => provider.is_current === true || provider.slug === options.provider;
+  return [...ready.filter(current), ...ready.filter((provider) => !current(provider))];
+}
+function choicesOf(options) {
+  const choices = [];
+  for (const provider of providersOf(options)) {
+    for (const model of provider.models ?? []) {
+      const id2 = choiceId(provider.slug, model);
+      if (choices.some((choice) => choice.id === id2)) continue;
+      choices.push({ id: id2, label: `${model} \xB7 ${provider.name ?? provider.slug}`.slice(0, LABEL_MAX), efforts: [] });
+    }
+  }
+  return choices;
+}
+function defaultOf(options) {
+  const model = options.model?.trim();
+  if (model === void 0 || model === "") return void 0;
+  return options.provider === void 0 || options.provider === "" ? model : choiceId(options.provider, model);
+}
+function matched(choices, model) {
+  if (choices.some((choice) => choice.id === model)) return model;
+  return choices.find((choice) => runModelOf(choice.id).model === model)?.id ?? model;
+}
+function copyOf(options, own2) {
+  let choices = choicesOf(options);
+  const fallback = defaultOf(options);
+  const byDefault = fallback === void 0 ? void 0 : matched(choices, fallback);
+  const mine = own2 === void 0 ? void 0 : matched(choices, own2);
+  const model = mine ?? byDefault ?? choices[0]?.id;
+  if (model === void 0) return void 0;
+  const keep = [model, ...byDefault === void 0 ? [] : [byDefault]];
+  for (const id2 of keep) {
+    if (!choices.some((choice) => choice.id === id2)) choices = [{ id: id2, label: id2.slice(0, LABEL_MAX), efforts: [] }, ...choices];
+  }
+  let others = MODEL_CHOICES_MAX2 - keep.filter((id2, at) => keep.indexOf(id2) === at).length;
+  choices = choices.filter((choice) => keep.includes(choice.id) || others-- > 0);
   return {
-    context: (edit) => bridge2().onContextEdit(edit),
-    contextWindows: {
-      compact: async (ask2) => bridge2().onWindowCompact(ask2),
-      change: async (ask2) => bridge2().onWindowChange(ask2)
-    }
+    model,
+    own: mine !== void 0,
+    ...byDefault === void 0 ? {} : { default: { label: DEFAULT_LABEL, model: byDefault } },
+    choices,
+    editable: true
   };
 }
-function filesHere(project = false) {
-  return `${sendingFiles({ project })} Hermes's note that this API server sends only pictures, and shows a MEDIA: tag on the runs endpoint as text, does not hold for these runs: they come from Chips, whose bridge takes each MEDIA: line out of your answer and attaches that file to your message, whatever its type, up to 100 MB.`;
+
+// src/profiles.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync9, readFileSync as readFileSync9, rmSync as rmSync4 } from "node:fs";
+import { createConnection } from "node:net";
+import { join as join9 } from "node:path";
+
+// src/gateway.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { accessSync as accessSync2, appendFileSync as appendFileSync2, closeSync as closeSync2, constants as constants2, existsSync as existsSync8, openSync as openSync2, readFileSync as readFileSync8, readSync, statSync as statSync3 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename4, delimiter as delimiter2, dirname as dirname5, join as join8, resolve as resolve3 } from "node:path";
+var TIMING = {
+  stopMs: 15e3,
+  killMs: 5e3,
+  earlyMs: 1e4,
+  upMs: 9e4,
+  serviceMs: 15e4,
+  pollMs: 500
+};
+var EXPAT = "/opt/homebrew/opt/expat/lib/libexpat.1.dylib";
+var EXPAT_SYMBOL = "_XML_SetAllocTrackerActivationThreshold";
+function gatewaysOf(agents) {
+  return [...new Set(agents.map(({ address }) => address.url.replace(/\/+$/, "")))].map((url2) => ({ url: url2 }));
 }
-var FILES_HERE = filesHere();
-function instructionsFor(folder2, project = false) {
-  const files = filesHere(project);
-  return folder2 === void 0 ? files : `${files} Your own folder is ${folder2}: make and keep your files there, and run your commands from there.`;
+function isLocal(url2) {
+  try {
+    return ["127.0.0.1", "localhost", "[::1]", "::1"].includes(new URL(url2).hostname);
+  } catch {
+    return false;
+  }
 }
-function freeFolder(root2, name2, taken) {
-  const slug = name2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
-  for (let count = 1; ; count += 1) {
-    const folder2 = join8(root2, count === 1 ? slug : `${slug}-${count}`);
-    if (!taken.includes(folder2)) return folder2;
+function portOf(url2) {
+  const parsed = new URL(url2);
+  return Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
+}
+function line(words4) {
+  const one = words4.replace(/\s+/g, " ").trim();
+  return one.length <= 200 ? one : `${one.slice(0, 199)}\u2026`;
+}
+function whyFrom(output2, code) {
+  const lines2 = output2.split("\n").map((each) => each.trim()).filter((each) => each !== "");
+  const why = lines2.findLast((each) => /^[A-Za-z_][\w.]*(Error|Exception)\b/.test(each)) ?? lines2.at(-1);
+  if (why === void 0) return code === null || code === void 0 ? "it was stopped" : `it exited ${code}`;
+  return why.length <= 200 ? why : why.replace(/\/(?:[^\s/(),:'"]+\/)+([^\s/(),:'"]+)/g, "$1");
+}
+function gatewayRunArgs(command) {
+  const words4 = command.trim().split(/\s+/);
+  const at = words4.findIndex((word) => basename4(word) === "hermes");
+  if (at === -1) return void 0;
+  const args = words4.slice(at + 1);
+  const plain = [];
+  for (let next = 0; next < args.length; next += 1) {
+    const word = args[next] ?? "";
+    if (word === "-p" || word === "--profile") next += 1;
+    else if (!word.startsWith("-")) plain.push(word);
   }
+  return plain[0] === "gateway" && plain[1] === "run" ? args : void 0;
 }
-var ids = createIdGenerator();
-var QUIET_MS = 1500;
-var LOST_STREAM_MS = 12e4;
-var KEPT_FEEDBACK = 500;
-var KINDS = {
-  terminal: "shell",
-  process: "shell",
-  execute_code: "shell",
-  web_search: "search",
-  search_files: "search",
-  session_search: "search",
-  web_extract: "web",
-  read_file: "file",
-  write_file: "edit",
-  patch: "edit",
-  vision_analyze: "image",
-  image_generate: "image",
-  memory: "memory",
-  delegate_task: "handoff"
-};
-function keyOf(agent) {
-  return `hermes:${(agent.address.profile ?? "default").toLowerCase()}:${agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+function serviceOf(system, root2, env = {}) {
+  const home2 = resolve3(root2);
+  const native = resolve3(system.home, ".hermes");
+  const suffix = home2 === native ? "" : dirname5(home2) === join8(native, "profiles") ? basename4(home2) : createHash3("sha256").update(home2).digest("hex").slice(0, 8);
+  if (system.platform === "darwin") {
+    const path = join8(system.home, "Library", "LaunchAgents", `ai.hermes.gateway${suffix ? `-${suffix}` : ""}.plist`);
+    return system.exists(path) ? { kind: "launchd", path } : void 0;
+  }
+  if (system.platform === "linux") {
+    const unit = `hermes-gateway${suffix ? `-${suffix}` : ""}.service`;
+    const user = join8(env["XDG_CONFIG_HOME"] || join8(system.home, ".config"), "systemd", "user", unit);
+    if (system.exists(user)) return { kind: "systemd", path: user };
+    const machine = join8("/etc/systemd/system", unit);
+    if (system.exists(machine)) return { kind: "systemd", path: machine, system: true };
+  }
+  return void 0;
 }
-var Bridge = class {
+function expand(text, env) {
+  let out = "";
+  let at = 0;
+  while (at < text.length) {
+    const char = text[at] ?? "";
+    if (char === "\\" && at + 1 < text.length) {
+      out += text[at + 1];
+      at += 2;
+    } else if (char !== "$") {
+      out += char;
+      at += 1;
+    } else if (text[at + 1] === "{") {
+      let depth = 1;
+      let end2 = at + 2;
+      for (; end2 < text.length; end2 += 1) {
+        if (text[end2] === "{") depth += 1;
+        else if (text[end2] === "}" && --depth === 0) break;
+      }
+      const inner = /^([A-Za-z_][A-Za-z0-9_]*)(?:(:?)-([\s\S]*))?$/.exec(text.slice(at + 2, end2));
+      if (inner !== null) {
+        const value = env[inner[1] ?? ""];
+        const unset = inner[2] === ":" ? value === void 0 || value === "" : value === void 0;
+        out += inner[3] !== void 0 && unset ? expand(inner[3], env) : value ?? "";
+      }
+      at = end2 + 1;
+    } else {
+      const name2 = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(at + 1))?.[0];
+      out += name2 === void 0 ? "$" : env[name2] ?? "";
+      at += 1 + (name2?.length ?? 0);
+    }
+  }
+  return out;
+}
+function wrapperOf(text, env) {
+  for (const each of text.split("\n")) {
+    const found = /^\s*((?:[A-Za-z_][A-Za-z0-9_]*="(?:[^"\\]|\\.)*"\s+)*)exec\s+"([^"]+)"/.exec(each);
+    if (found === null) continue;
+    const vars = {};
+    for (const set2 of (found[1] ?? "").matchAll(/([A-Za-z_][A-Za-z0-9_]*)="((?:[^"\\]|\\.)*)"/g)) {
+      vars[set2[1] ?? ""] = expand(set2[2] ?? "", env);
+    }
+    return { entry: expand(found[2] ?? "", env), vars };
+  }
+  return void 0;
+}
+var NO_HERMES = "The hermes command isn't on this machine's PATH, so Hermes's gateway can't be started.";
+var messageOf2 = (error62) => error62 instanceof Error ? error62.message : String(error62);
+function gatewayEnv(env) {
+  return Object.fromEntries(Object.entries(env).filter(([name2]) => !name2.startsWith("CHIPS_")));
+}
+async function runHermes(system, env, args, timeoutMs, log2) {
+  const hermes = system.which("hermes", env);
+  if (hermes === void 0) return { code: null, output: "The hermes command isn't on this machine's PATH." };
+  const plain = gatewayEnv(env);
+  const ran = await system.run(hermes, args, plain, timeoutMs);
+  if (ran.code === 0 || !ran.output.includes(EXPAT_SYMBOL) || !system.exists(EXPAT)) return ran;
+  const wrapper = wrapperOf(system.read(hermes) ?? "", plain);
+  if (wrapper === void 0) return ran;
+  const expat = dirname5(EXPAT);
+  log2(
+    `hermes ${args.slice(0, 2).join(" ")} stopped at once: Homebrew's Python can't load macOS's expat (${EXPAT_SYMBOL}). Running ${wrapper.entry} directly with DYLD_LIBRARY_PATH=${expat}.`
+  );
+  const libraries = [expat, plain["DYLD_LIBRARY_PATH"]].filter((each) => each !== void 0 && each !== "").join(":");
+  return system.run(wrapper.entry, args, { ...plain, ...wrapper.vars, DYLD_LIBRARY_PATH: libraries }, timeoutMs);
+}
+var Gateways = class {
   constructor(options) {
     this.options = options;
-    this.log = options.log ?? (() => void 0);
-    const { chips: chips2, hermesRoot: hermesRoot2 } = options;
-    if (hermesRoot2 === void 0) return;
-    this.contexts = new Contexts(
-      () => this.roster(),
-      {
-        agent: (agentId2, copy) => chips2.settings.context(agentId2, copy),
-        harness: (copy) => chips2.settings.harnessContext(copy)
-      },
-      (line2) => this.log(`context: ${line2}`),
-      options.env ?? process.env
-    );
-    if (options.fills === void 0) return;
-    const kept = options.state.fills ??= {};
-    this.fills = new Fills({
-      whose: (sessionId) => this.whoseSession(sessionId),
-      profileOf: (agentId2) => {
-        const profile = this.profileFor(agentId2);
-        return profile === void 0 ? void 0 : { profile: profile.name, home: profile.home };
-      },
-      secretFor: (profile) => envValue(profileHome(hermesRoot2, profile), SECRET_ENV) ?? kept.secret ?? options.fills?.secret,
-      send: (agentId2, copy) => chips2.settings.contextWindow(agentId2, copy),
-      kept,
-      save: () => options.saveState(options.state),
-      log: (line2) => this.log(`context window: ${line2}`),
-      sendEveryMs: options.fillsEveryMs
-    });
   }
   options;
-  agents = [];
-  rooms = /* @__PURE__ */ new Map();
-  /** Every Chips agent of the harness's, configured here or not. */
-  ours = /* @__PURE__ */ new Set();
-  /** The harness's agents' names, by Chips id, for the folders named after them. */
-  names = /* @__PURE__ */ new Map();
-  /** The feedback events answered with a turn, the newest `KEPT_FEEDBACK`. */
-  lookedAt = /* @__PURE__ */ new Set();
-  /** The copies being made, one after another: a message for one waits for it (see `copy`). */
-  copying = Promise.resolve();
-  log;
-  health;
-  /** The harness's agents in Chips as last listed: whose context and window copies are sent. */
-  listed = [];
-  /** The agents' context files (Chips ADR 0134), when the bridge knows where Hermes keeps them. */
-  contexts;
-  contextTimer;
-  /** The agents' context windows (Chips ADR 0146), when Hermes's webhook has somewhere to reach. */
-  fills;
-  /** The port Hermes's webhook reaches the bridge on, once it listens. */
-  fillsPort;
-  toldNoReadings = false;
-  /** While Hermes's gateway restarts (Chips ADR 0094), the health watch says nothing: the restart says how it went. */
-  held = false;
-  /** What went wrong in the last restart, said in place of the watch's own words while Hermes doesn't answer. */
-  why;
-  /** Register the agents, start hearing what is said to them, and say how their gateways are. */
-  async start() {
-    const { chips: chips2 } = this.options;
-    const known = await chips2.agents.list();
-    for (const [index, config3] of this.options.agents.entries()) {
-      const key = keyOf(config3);
-      const registered = index === 0 ? await this.seatMain(config3, known) : await chips2.agents.register({ key, name: config3.name });
-      const client = this.options.clientFor?.(config3) ?? new HermesClient(config3.address);
-      this.agents.push({ config: config3, key, client, agentId: registered.agentId, up: true });
-    }
-    this.ours = /* @__PURE__ */ new Set([...known.map((agent) => agent.agentId), ...this.agents.map((agent) => agent.agentId)]);
-    chips2.on("message.new", (message) => void this.hear(message));
-    chips2.on("agent.asked", (asked) => {
-      this.make(asked).catch((error62) => this.log(`a new agent went wrong: ${messageOf2(error62)}`));
-    });
-    chips2.on("agent.fork", (fork) => {
-      this.copying = this.copying.then(() => this.copy(fork)).catch((error62) => this.log(`a copy went wrong: ${messageOf2(error62)}`));
-    });
-    chips2.on("feedback", (feedback2) => {
-      this.notRight(feedback2).catch((error62) => this.log(`a note on a reply went wrong: ${messageOf2(error62)}`));
-    });
-    chips2.on("agent.attached", () => void this.agentsMoved());
-    chips2.on("agent.released", () => void this.agentsMoved());
-    await this.sayHowItIs();
-    this.health = setInterval(() => void this.sayHowItIs(), this.options.healthEveryMs ?? 3e4);
-    this.health.unref();
-    await this.startSettings();
+  timing = TIMING;
+  /** Each gateway restarted, one after another: what went wrong, in a line, or nothing. */
+  async restart() {
+    const troubles = [];
+    for (const gateway of this.options.gateways) {
+      let trouble;
+      try {
+        trouble = await this.restartOne(gateway);
+      } catch (error62) {
+        trouble = `Restart failed: ${messageOf2(error62)}`;
+      }
+      if (trouble !== void 0) troubles.push(trouble);
+    }
+    return troubles.length === 0 ? void 0 : line(troubles.join(" "));
   }
-  /** Hold the health watch's words while Hermes's gateway restarts, and let them go after. */
-  hold(held) {
-    this.held = held;
+  /** Each local gateway that doesn't answer, started: the bridge is starting. */
+  async startIfDown() {
+    const { system, log: log2 } = this.options;
+    for (const gateway of this.options.gateways) {
+      if (!isLocal(gateway.url)) continue;
+      const port = portOf(gateway.url);
+      try {
+        if (await system.healthy(gateway.url)) continue;
+        let trouble;
+        if (this.serviceFor(gateway) !== void 0) {
+          log2(`Hermes isn't answering on port ${port}: starting its service, hermes gateway start`);
+          trouble = await this.byService(gateway, "start", void 0);
+        } else {
+          const pid = await system.listener(port);
+          if (pid !== void 0) {
+            log2(`Hermes isn't answering on port ${port}, but pid ${pid} listens there: no second gateway started`);
+            continue;
+          }
+          log2(`Hermes isn't answering on port ${port}: starting hermes gateway run`);
+          trouble = await this.start(gateway, ["gateway", "run"], void 0);
+        }
+        if (trouble !== void 0) log2(trouble);
+      } catch (error62) {
+        log2(`Hermes's gateway on port ${port} couldn't be started: ${messageOf2(error62)}`);
+      }
+    }
   }
   /**
-   * How a restart went (Chips ADR 0094): fine as the gateways now are, or its words, which stand
-   * while Hermes doesn't answer. The health watch speaks for itself again after.
+   * The service of Hermes's root, for the Main agent's gateway: a gateway at another address is
+   * another profile's own, which `hermes gateway status` of the root doesn't speak for.
    */
-  async restarted(trouble) {
-    this.held = false;
-    this.why = trouble;
-    if (trouble === void 0) return this.sayHowItIs();
-    await this.options.chips.reportTrouble(trouble).catch(() => void 0);
-  }
-  stop() {
-    if (this.health !== void 0) clearInterval(this.health);
-    if (this.contextTimer !== void 0) clearInterval(this.contextTimer);
-    void this.fills?.close();
+  serviceFor(gateway) {
+    if (gateway !== this.options.gateways[0]) return void 0;
+    return serviceOf(this.options.system, this.options.root, this.options.env);
   }
-  // ------------------------------------------------------------------ an agent's page
-  /**
-   * The agents' context and context windows, sent at start and kept current: the files read
-   * again every so often and after each turn, a window copy on each reading Hermes sends.
-   */
-  async startSettings() {
-    if (this.contexts === void 0) return;
-    this.listed = await this.options.chips.agents.list().catch(() => this.listed);
-    await this.contexts.refresh();
-    this.contextTimer = setInterval(() => void this.contexts?.refresh(), this.options.contextEveryMs ?? 15e3);
-    this.contextTimer.unref();
-    const fills2 = this.fills;
-    const asked = this.options.fills;
-    if (fills2 === void 0 || asked === void 0) return;
-    const kept = this.options.state.fills ??= {};
-    try {
-      this.fillsPort = await fills2.listen(asked.port);
-      if (kept.port !== this.fillsPort) {
-        kept.port = this.fillsPort;
-        this.options.saveState(this.options.state);
-      }
-    } catch (error62) {
-      this.log(`context window: nothing can listen on port ${asked.port} (${messageOf2(error62)}), so Chips won't show how full each agent's context is`);
+  async restartOne(gateway) {
+    const { system, log: log2 } = this.options;
+    if (!isLocal(gateway.url)) {
+      return `Hermes's gateway at ${new URL(gateway.url).host} isn't on this machine, so it can't be restarted from here.`;
     }
-    await fills2.sendAll();
-  }
-  /** The address Hermes's webhook POSTs a profile's readings to, once the bridge listens. */
-  hookUrl(profile = "default") {
-    return this.fillsPort === void 0 ? void 0 : hookUrl(this.fillsPort, profileName(profile));
-  }
-  /** The harness's agents listed again, the copies of any gone forgotten, and the context sent. */
-  async agentsMoved() {
-    if (this.contexts === void 0) return;
-    const before = this.listed;
-    this.listed = await this.options.chips.agents.list().catch(() => this.listed);
-    const now = new Set(this.active().map((agent) => agent.agentId));
-    for (const gone of before) {
-      if (now.has(gone.agentId)) continue;
-      this.options.chips.settings.forget(gone.agentId);
-      this.fills?.forget(gone.agentId);
+    const port = portOf(gateway.url);
+    const pid = await system.listener(port);
+    if (this.serviceFor(gateway) !== void 0) {
+      log2("restarting Hermes's service: hermes gateway restart");
+      return this.byService(gateway, "restart", pid);
     }
-    await this.contexts.refresh();
-  }
-  /** The harness's agents that read anything now: the active ones listed. */
-  active() {
-    return this.listed.filter((agent) => agent.state === "active");
-  }
-  /** A profile as the context needs it: its name and its home under Hermes's root. */
-  profileOfRunning(agent) {
-    const root2 = this.options.hermesRoot;
-    if (root2 === void 0) return void 0;
-    return { name: profileName(agent.config.address.profile), home: profileHome(root2, agent.config.address.profile) };
-  }
-  /** The profile an agent runs on: its own, a copy's original's, else the first (as `profileOf` picks). */
-  profileFor(agentId2) {
-    const own2 = this.agents.find((agent) => agent.agentId === agentId2);
-    const copied = this.options.state.profiles?.[agentId2];
-    const original = this.agents.find((agent) => copied !== void 0 && agent.key === copied);
-    const running = own2 ?? original ?? this.agents[0];
-    return running === void 0 ? void 0 : this.profileOfRunning(running);
-  }
-  /** Who reads what: each active agent with its profile, and the first profile, which new agents run on. */
-  roster() {
-    const readers = [];
-    const ids2 = /* @__PURE__ */ new Set([...this.active().map((agent) => agent.agentId), ...this.agents.map((agent) => agent.agentId)]);
-    for (const agentId2 of ids2) {
-      if (this.listed.some((agent) => agent.agentId === agentId2 && agent.state !== "active")) continue;
-      const profile = this.profileFor(agentId2);
-      if (profile !== void 0) readers.push({ agentId: agentId2, profile });
+    if (pid === void 0) {
+      if (await system.healthy(gateway.url)) return `Can't tell what answers on port ${port}, so nothing was restarted.`;
+      log2(`nothing listens on port ${port}: starting hermes gateway run`);
+      return this.start(gateway, ["gateway", "run"], void 0);
     }
-    const first = this.agents[0];
-    return { readers, first: first === void 0 ? void 0 : this.profileOfRunning(first) };
-  }
-  /** The agent a Hermes session the bridge keeps is, with its profile: nothing for any other. */
-  whoseSession(sessionId) {
-    const entry = Object.entries(this.options.state.sessions).find(([, session]) => session === sessionId);
-    if (entry === void 0) return void 0;
-    const who = entry[0].slice(0, entry[0].lastIndexOf("|"));
-    const agentId2 = this.agents.find((agent) => agent.key === who)?.agentId ?? who;
-    const profile = this.profileFor(agentId2);
-    return profile === void 0 ? void 0 : { agentId: agentId2, profile: profile.name, home: profile.home };
-  }
-  /** A person's edit of a context file from Chips (Chips ADR 0134), saved and answered. */
-  async onContextEdit(frame) {
-    if (this.contexts === void 0) throw new Refuse("This bridge reads no context files.");
-    if (frame.agent_id !== void 0 && !this.listed.some((agent) => agent.agentId === frame.agent_id)) {
-      this.listed = await this.options.chips.agents.list().catch(() => this.listed);
+    const info = await system.describe(pid);
+    if (info === void 0) return this.start(gateway, ["gateway", "run"], void 0);
+    const args = this.ours(info);
+    if (args === void 0) {
+      log2(`pid ${pid} on port ${port} isn't this user's hermes gateway run, so it was left alone: ${info.command.slice(0, 160)}`);
+      return `Port ${port} is held by something other than hermes gateway run (pid ${pid}), so nothing was restarted.`;
     }
-    return this.contexts.edit(frame);
-  }
-  /** A person's Compact now (Chips ADR 0146): Hermes can't be asked to compact from outside a run. */
-  onWindowCompact(frame) {
-    throw new Refuse(WHY_NOT, this.fills?.copyOf(frame.agent_id));
+    if (system.which("hermes", this.options.env) === void 0) return NO_HERMES;
+    log2(`stopping Hermes's gateway, pid ${pid}`);
+    if (!await this.stop(pid)) return `Hermes's gateway (pid ${pid}) didn't stop, so it wasn't started again.`;
+    return this.start(gateway, args, info.cwd);
   }
-  /** A person's limit (Chips ADR 0146): Hermes sets it in its profile's config, for all its agents. */
-  onWindowChange(frame) {
-    const profile = this.profileFor(frame.agent_id);
-    throw new Refuse(whyReadOnly(profile?.name ?? "default"), this.fills?.copyOf(frame.agent_id));
+  /** A `hermes gateway run` of this user's: the words to start it again with. */
+  ours(info) {
+    return info.uid === this.options.system.uid ? gatewayRunArgs(info.command) : void 0;
   }
-  /** The Main agent, the first registered, once started: who says the harness's first words. */
-  get mainAgentId() {
-    return this.agents[0]?.agentId;
+  /** SIGTERM, then SIGKILL once it has had a while, and only while it is still that gateway. */
+  async stop(pid) {
+    const { system, log: log2 } = this.options;
+    system.signal(pid, "SIGTERM");
+    if (await this.gone(pid, this.timing.stopMs)) return true;
+    const still = await system.describe(pid);
+    if (still === void 0) return true;
+    if (this.ours(still) === void 0) return false;
+    log2(`Hermes's gateway, pid ${pid}, is still running ${this.timing.stopMs / 1e3} s after SIGTERM: SIGKILL`);
+    system.signal(pid, "SIGKILL");
+    return this.gone(pid, this.timing.killMs);
   }
-  /**
-   * The Main agent: the one Chips made for the harness when it joined, keyed by the harness's own
-   * id, registered as Main (Chips ADR 0183), so it is called what the config says and has no
-   * second beside it. It goes home, and a Main of ours from before that, out of its room now, is
-   * archived, which gives its name up. With no such agent (a harness from before them), the Main
-   * Chips has is kept: a harness has one at most.
-   */
-  async seatMain(config3, known) {
-    const { chips: chips2 } = this.options;
-    const before = known.find((agent) => agent.lead);
-    const made = known.some((agent) => agent.key === chips2.harnessId);
-    if (!made && before !== void 0) {
-      await this.goHome(before, known);
-      return before;
-    }
-    const main2 = await chips2.agents.register({ key: chips2.harnessId, name: config3.name, lead: true });
-    await this.goHome(main2, known);
-    if (before !== void 0 && before.agentId !== main2.agentId) {
-      await chips2.agents.register({ key: before.key, name: before.name, state: "archived" }).catch((error62) => this.log(`${before.name} stays: ${String(error62)}`));
+  async gone(pid, withinMs) {
+    const { system } = this.options;
+    const by = system.now() + withinMs;
+    while (system.alive(pid)) {
+      if (system.now() >= by) return false;
+      await system.sleep(this.timing.pollMs);
     }
-    return main2;
+    return true;
   }
-  /** The Main agent into the harness's own room, in the place of whichever of ours is there. */
-  async goHome(main2, known) {
-    const { chips: chips2, home: home2 } = this.options;
-    if (home2 === void 0 || main2.spaces.includes(home2)) return;
-    const there = known.find((agent) => agent.agentId !== main2.agentId && agent.spaces.includes(home2));
-    await chips2.agents.attach(main2.agentId, { spaceId: home2, replacing: there?.agentId ?? chips2.harnessId }).catch((error62) => this.log(`${main2.name} stays out of its home: ${String(error62)}`));
+  /** Hermes's own `hermes gateway restart|start`, then the gateway answering, from a new process. */
+  async byService(gateway, verb, before) {
+    const { system, env } = this.options;
+    const hermes = system.which("hermes", env);
+    if (hermes === void 0) return NO_HERMES;
+    const scope = this.serviceFor(gateway)?.system === true ? ["--system"] : [];
+    const ran = await system.run(hermes, ["gateway", verb, ...scope], gatewayEnv(env), this.timing.serviceMs);
+    if (ran.code !== 0) return line(`hermes gateway ${verb} failed: ${whyFrom(ran.output, ran.code)}`);
+    const by = system.now() + this.timing.serviceMs;
+    for (; ; ) {
+      const old = before !== void 0 && system.alive(before);
+      if (!old && await system.healthy(gateway.url)) return void 0;
+      if (system.now() >= by) {
+        if (await system.healthy(gateway.url)) return void 0;
+        return `Hermes's service ${verb === "start" ? "started" : "restarted"}, but nothing answers on port ${portOf(gateway.url)}.`;
+      }
+      await system.sleep(this.timing.pollMs);
+    }
   }
   /**
-   * A person asked for a new agent in a room (Chips ADR 0108): one of the harness's, keyed by the
-   * ask so an ask heard twice makes one, registered for the room, which Chips puts it in while the
-   * room waits. It answers through the first profile, in a session of its own.
+   * `hermes <args>` (`gateway run`), on its own, in `cwd` (else the home), then through Homebrew's
+   * expat when it died of macOS's.
    */
-  async make(asked) {
-    const { chips: chips2 } = this.options;
-    if (asked.harness_id !== chips2.harnessId || asked.space_id === void 0) return;
-    const agent = await chips2.agents.register({
-      key: `hermes:asked:${asked.id}`,
-      name: asked.name,
-      madeFor: asked.id,
-      spaceId: asked.space_id
-    });
-    this.ours.add(agent.agentId);
-    this.names.set(agent.agentId, agent.name);
-    this.log(`${agent.name} made${agent.attached === false ? `, not in the room: ${agent.why ?? "too late"}` : ""}`);
-    void this.agentsMoved();
+  async start(gateway, args, cwd) {
+    const { system, env, log: log2 } = this.options;
+    const port = portOf(gateway.url);
+    const hermes = system.which("hermes", env);
+    if (hermes === void 0) return NO_HERMES;
+    const folder2 = cwd ?? system.home;
+    const plain = gatewayEnv(env);
+    let outcome = await this.launch(gateway, hermes, args, plain, folder2, `hermes ${args.join(" ")}`);
+    if (outcome.state === "ended" && outcome.early && outcome.output.includes(EXPAT_SYMBOL) && system.exists(EXPAT)) {
+      const wrapper = wrapperOf(system.read(hermes) ?? "", plain);
+      if (wrapper !== void 0) {
+        const expat = dirname5(EXPAT);
+        log2(
+          `hermes gateway run stopped at once: Homebrew's Python can't load macOS's expat (${EXPAT_SYMBOL}). Starting ${wrapper.entry} directly with DYLD_LIBRARY_PATH=${expat}.`
+        );
+        const libraries = [expat, plain["DYLD_LIBRARY_PATH"]].filter((each) => each !== void 0 && each !== "").join(":");
+        outcome = await this.launch(
+          gateway,
+          wrapper.entry,
+          args,
+          { ...plain, ...wrapper.vars, DYLD_LIBRARY_PATH: libraries },
+          folder2,
+          `${wrapper.entry} ${args.join(" ")} with DYLD_LIBRARY_PATH=${expat}`
+        );
+      }
+    }
+    if (outcome.state === "up") {
+      log2(`Hermes's gateway${outcome.pid === void 0 ? "" : `, pid ${outcome.pid},`} answers on port ${port}. It logs to ${this.options.logFile}.`);
+      return void 0;
+    }
+    if (outcome.state === "silent") return `Hermes's gateway started, but nothing answers on port ${port}.`;
+    return line(`Hermes's gateway stopped as it started: ${whyFrom(outcome.output, outcome.code)}`);
+  }
+  /** A program started, and watched until it answers, ends, or has had its time. */
+  async launch(gateway, command, args, env, cwd, what) {
+    const { system, logFile } = this.options;
+    system.note(logFile, `--- ${new Date(system.now()).toISOString()} chips-hermes started ${what}`);
+    const from = system.size(logFile);
+    const startedAt = system.now();
+    const child = system.launch({ command, args, env, cwd, log: logFile });
+    let ended;
+    void child.exited.then(({ code }) => {
+      ended = { code, at: system.now() };
+    });
+    for (; ; ) {
+      await Promise.resolve();
+      if (ended !== void 0) {
+        return { state: "ended", early: ended.at - startedAt <= this.timing.earlyMs, output: system.since(logFile, from), code: ended.code };
+      }
+      if (await system.healthy(gateway.url)) return { state: "up", pid: child.pid };
+      if (system.now() - startedAt >= this.timing.upMs) return { state: "silent" };
+      await system.sleep(this.timing.pollMs);
+    }
+  }
+};
+function restarter(deps) {
+  let running;
+  return (ask2) => {
+    if (running !== void 0) {
+      deps.log(`restart asked by ${ask2.askedBy} while one runs: it is the same restart`);
+      return running;
+    }
+    running = (async () => {
+      deps.log(`restart asked by ${ask2.askedBy}: restarting Hermes's gateway`);
+      deps.hold(true);
+      let trouble;
+      try {
+        trouble = await deps.restart();
+      } catch (error62) {
+        trouble = line(`Restart failed: ${error62 instanceof Error ? error62.message : String(error62)}`);
+      }
+      deps.log(trouble === void 0 ? "restarted, and Hermes answers" : `restart: ${trouble}`);
+      try {
+        await deps.say(trouble);
+      } catch (error62) {
+        deps.log(`could not tell Chips how the restart went: ${String(error62)}`);
+      } finally {
+        deps.hold(false);
+      }
+    })().finally(() => {
+      running = void 0;
+    });
+    return running;
+  };
+}
+function gatewayLog(configFolder, platform = process.platform) {
+  return platform === "darwin" ? join8(homedir5(), "Library", "Logs", "chips-hermes-gateway.log") : join8(configFolder, "gateway.log");
+}
+function runToEnd(command, args, options) {
+  return new Promise((done) => {
+    const child = spawn2(command, args, { env: options.env, stdio: ["ignore", "pipe", "pipe"] });
+    let output2 = "";
+    const keep = (data) => {
+      output2 = (output2 + String(data)).slice(-8e3);
+    };
+    child.stdout.on("data", keep);
+    child.stderr.on("data", keep);
+    const limit = setTimeout(() => child.kill("SIGTERM"), options.timeoutMs);
+    child.on("error", (error62) => {
+      clearTimeout(limit);
+      done({ code: null, output: error62.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(limit);
+      done({ code, output: output2 });
+    });
+  });
+}
+function thisMachine() {
+  return {
+    platform: process.platform,
+    uid: process.getuid?.() ?? -1,
+    home: homedir5(),
+    exists: existsSync8,
+    read(path) {
+      try {
+        return readFileSync8(path, "utf8");
+      } catch {
+        return void 0;
+      }
+    },
+    which(command, env) {
+      for (const folder2 of (env["PATH"] ?? "").split(delimiter2)) {
+        if (folder2 === "") continue;
+        const path = join8(folder2, command);
+        try {
+          accessSync2(path, constants2.X_OK);
+          return path;
+        } catch {
+        }
+      }
+      return void 0;
+    },
+    async listener(port) {
+      const { output: output2 } = await runToEnd("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fp"], { timeoutMs: 5e3 });
+      const pid = Number(/^p(\d+)$/m.exec(output2)?.[1]);
+      return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+    },
+    async describe(pid) {
+      const { code, output: output2 } = await runToEnd("ps", ["-ww", "-o", "uid=", "-o", "command=", "-p", String(pid)], { timeoutMs: 5e3 });
+      const found = /^\s*(\d+)\s+(.*)$/m.exec(output2);
+      if (code !== 0 || found === null) return void 0;
+      return { uid: Number(found[1]), command: found[2] ?? "", cwd: processFolder(pid) };
+    },
+    alive(pid) {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error62) {
+        return error62.code === "EPERM";
+      }
+    },
+    signal(pid, signal) {
+      try {
+        process.kill(pid, signal);
+      } catch {
+      }
+    },
+    run: (command, args, env, timeoutMs) => runToEnd(command, args, { env, timeoutMs }),
+    launch({ command, args, env, cwd, log: log2 }) {
+      const out = openSync2(log2, "a");
+      try {
+        const child = spawn2(command, args, { cwd, env, detached: true, stdio: ["ignore", out, out] });
+        const exited = new Promise((done) => {
+          child.once("exit", (code, signal) => done({ code, signal }));
+          child.once("error", (error62) => {
+            appendFileSync2(log2, `${error62.message}
+`);
+            done({ code: null, signal: null });
+          });
+        });
+        child.unref();
+        return { pid: child.pid, exited };
+      } finally {
+        closeSync2(out);
+      }
+    },
+    note(log2, words4) {
+      appendFileSync2(log2, `${words4}
+`);
+    },
+    size(log2) {
+      try {
+        return statSync3(log2).size;
+      } catch {
+        return 0;
+      }
+    },
+    since(log2, from) {
+      try {
+        const to = statSync3(log2).size;
+        const start = Math.max(from, to - 64e3);
+        const buffer = Buffer.alloc(Math.max(0, to - start));
+        const fd = openSync2(log2, "r");
+        try {
+          readSync(fd, buffer, 0, buffer.length, start);
+        } finally {
+          closeSync2(fd);
+        }
+        return buffer.toString("utf8");
+      } catch {
+        return "";
+      }
+    },
+    healthy: (url2) => new HermesClient({ url: url2, key: "" }, (input2, init) => fetch(input2, { ...init, signal: AbortSignal.timeout(5e3) })).healthy(),
+    sleep: (ms) => new Promise((done) => setTimeout(done, ms)),
+    now: () => Date.now()
+  };
+}
+
+// src/profiles.ts
+var KEY_ENV = "API_SERVER_KEY";
+var RESERVED = /* @__PURE__ */ new Set(["hermes", "default", "test", "tmp", "root", "sudo"]);
+var CREATE_MS = 12e4;
+function freeProfile(root2, name2, taken) {
+  const slug = name2.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 56).replace(/^-+|-+$/g, "") || "agent";
+  for (let count = 1; ; count += 1) {
+    if (count === 1 && RESERVED.has(slug)) continue;
+    const profile = count === 1 ? slug : `${slug}-${count}`;
+    if (!taken.includes(profile) && !existsSync9(join9(root2, "profiles", profile))) return profile;
+  }
+}
+function readyProfile(home2, names, hook) {
+  for (const file3 of ["MEMORY.md", "USER.md"]) rmSync4(join9(home2, "memories", file3), { force: true });
+  if (envValue(home2, KEY_ENV) === void 0) appendEnv(home2, KEY_ENV, randomBytes2(32).toString("hex"));
+  if (hook === void 0) return void 0;
+  const path = join9(home2, "config.yaml");
+  if (existsSync9(path)) {
+    const theirs = hookUrl(hook.port, names.from).replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+    const entry = new RegExp(`^(\\s*(?:-\\s*)?url:\\s*["']?)${theirs}(["']?\\s*(?:#.*)?)$`, "m");
+    const text = readFileSync9(path, "utf8");
+    if (entry.test(text)) writeWhole(path, text.replace(entry, `$1${hookUrl(hook.port, names.profile)}$2`));
+  }
+  return addHook(home2, hook.port, names.profile, hook.secret);
+}
+function hermesProfiles(options) {
+  return {
+    async create(name2, from) {
+      const args = ["profile", "create", name2, "--clone-from", from, "--no-alias"];
+      const ran = await runHermes(options.system, options.env, args, CREATE_MS, options.log);
+      if (ran.code !== 0) throw new Error(whyFrom(ran.output, ran.code).replace(/^Error:\s*/, ""));
+    },
+    async serve() {
+      const result = await askGateway(options.root, "rescan-profiles");
+      return typeof result?.["multiplex"] === "boolean" ? result["multiplex"] : void 0;
+    }
+  };
+}
+function controlSocketOf(root2) {
+  const direct = join9(root2, "gateway.sock");
+  if (existsSync9(direct)) return direct;
+  try {
+    const pointed = readFileSync9(join9(root2, "gateway.sock.path"), "utf8").trim();
+    return pointed !== "" && existsSync9(pointed) ? pointed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function askGateway(root2, verb, timeoutMs = 8e3) {
+  const path = controlSocketOf(root2);
+  if (path === void 0) return Promise.resolve(void 0);
+  return new Promise((done) => {
+    let heard = "";
+    let over = false;
+    const socket = createConnection(path);
+    const finish = (line2) => {
+      if (over) return;
+      over = true;
+      clearTimeout(timer);
+      socket.destroy();
+      done(line2 === void 0 ? void 0 : resultOf(line2));
+    };
+    const timer = setTimeout(() => finish(void 0), timeoutMs);
+    socket.on("connect", () => socket.write(`${JSON.stringify({ verb, id: 1, protocol: 1 })}
+`));
+    socket.on("data", (chunk) => {
+      heard += String(chunk);
+      const end2 = heard.indexOf("\n");
+      if (end2 >= 0) finish(heard.slice(0, end2));
+    });
+    socket.on("end", () => finish(heard));
+    socket.on("error", () => finish(void 0));
+  });
+}
+function resultOf(line2) {
+  try {
+    const answer = JSON.parse(line2);
+    return answer.ok === true && typeof answer.result === "object" && answer.result !== null ? answer.result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/bridge.ts
+var WANTS = [
+  "agents",
+  "new_spaces",
+  "new_agents",
+  "forks",
+  "context_files",
+  "models",
+  "context_windows",
+  "restarts"
+];
+function settingsFor(active) {
+  const bridge2 = () => {
+    const there = active();
+    if (there === void 0) throw new Refuse("The bridge is starting. Try again in a moment.");
+    return there;
+  };
+  return {
+    context: (edit) => bridge2().onContextEdit(edit),
+    models: (change) => bridge2().onModelChange(change),
+    contextWindows: {
+      compact: async (ask2) => bridge2().onWindowCompact(ask2),
+      change: async (ask2) => bridge2().onWindowChange(ask2)
+    }
+  };
+}
+function filesHere(project = false) {
+  return `${sendingFiles({ project })} Hermes's note that this API server sends only pictures, and shows a MEDIA: tag on the runs endpoint as text, does not hold for these runs: they come from Chips, whose bridge takes each MEDIA: line out of your answer and attaches that file to your message, whatever its type, up to 100 MB.`;
+}
+var FILES_HERE = filesHere();
+function instructionsFor(folder2, project = false) {
+  const files = filesHere(project);
+  return folder2 === void 0 ? files : `${files} Your own folder is ${folder2}: make and keep your files there, and run your commands from there.`;
+}
+function freeFolder(root2, name2, taken) {
+  const slug = name2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+  for (let count = 1; ; count += 1) {
+    const folder2 = join10(root2, count === 1 ? slug : `${slug}-${count}`);
+    if (!taken.includes(folder2)) return folder2;
+  }
+}
+var ids = createIdGenerator();
+var QUIET_MS = 1500;
+var LOST_STREAM_MS = 12e4;
+var KEPT_FEEDBACK = 500;
+var KINDS = {
+  terminal: "shell",
+  process: "shell",
+  execute_code: "shell",
+  web_search: "search",
+  search_files: "search",
+  session_search: "search",
+  web_extract: "web",
+  read_file: "file",
+  write_file: "edit",
+  patch: "edit",
+  vision_analyze: "image",
+  image_generate: "image",
+  memory: "memory",
+  delegate_task: "handoff"
+};
+function keyOf(agent) {
+  return `hermes:${(agent.address.profile ?? "default").toLowerCase()}:${agent.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+}
+var Bridge = class {
+  constructor(options) {
+    this.options = options;
+    this.log = options.log ?? (() => void 0);
+    const { chips: chips2, hermesRoot: hermesRoot2 } = options;
+    if (hermesRoot2 === void 0) return;
+    this.contexts = new Contexts(
+      () => this.roster(),
+      {
+        agent: (agentId2, copy) => chips2.settings.context(agentId2, copy),
+        harness: (copy) => chips2.settings.harnessContext(copy)
+      },
+      (line2) => this.log(`context: ${line2}`),
+      options.env ?? process.env
+    );
+    if (options.fills === void 0) return;
+    const kept = options.state.fills ??= {};
+    this.fills = new Fills({
+      whose: (sessionId) => this.whoseSession(sessionId),
+      profileOf: (agentId2) => {
+        const profile = this.profileFor(agentId2);
+        return profile === void 0 ? void 0 : { profile: profile.name, home: profile.home };
+      },
+      secretFor: (profile) => envValue(profileHome(hermesRoot2, profile), SECRET_ENV) ?? kept.secret ?? options.fills?.secret,
+      send: (agentId2, copy) => chips2.settings.contextWindow(agentId2, copy),
+      kept,
+      save: () => options.saveState(options.state),
+      log: (line2) => this.log(`context window: ${line2}`),
+      sendEveryMs: options.fillsEveryMs
+    });
   }
+  options;
+  agents = [];
+  rooms = /* @__PURE__ */ new Map();
+  /** Every Chips agent of the harness's, configured here or not. */
+  ours = /* @__PURE__ */ new Set();
+  /** The harness's agents' names, by Chips id, for the folders named after them. */
+  names = /* @__PURE__ */ new Map();
+  /** The agents made in Chips with a profile of their own, by Chips id (Chips ADR 0241). */
+  own = /* @__PURE__ */ new Map();
+  /** The feedback events answered with a turn, the newest `KEPT_FEEDBACK`. */
+  lookedAt = /* @__PURE__ */ new Set();
   /**
-   * A person asked for a copy of one of the harness's agents in another room (ADR 0087, Fork): the
-   * agent's session in the room it is in, else the last it had, forked in Hermes, is the copy's
-   * session in the room asked. The copy answers through its original's profile, whose Hermes has
-   * that session, and works in its original's folder. It is registered with `forkedFrom` for the
-   * room, which Chips puts it in while the room waits. The fork and the copy are keyed by the ask,
-   * so an ask heard twice forks once (Hermes refuses the id again) and registers the same copy. An
-   * agent that never spoke is copied with nothing to remember. A turn still going is not in the
-   * copy: Hermes copies what the session holds. Nothing is made for an ask the room has stopped
-   * waiting for (`FORK_WAIT_MS`), nor for an agent that isn't the harness's.
+   * The agents made, the spaces claimed and the copies made, one after another: a message for an
+   * agent not settled yet waits for them (see `runnerOf`).
    */
-  async copy(fork) {
-    const { chips: chips2, state: state2 } = this.options;
-    const spaceId = fork.space_id;
-    if (spaceId === void 0) return;
-    const late = Date.now() - Date.parse(fork.ts);
-    if (late > FORK_WAIT_MS) {
-      this.log(`no copy of ${fork.agent_id}: asked ${Math.round(late / 1e3)} s ago, and the room waits a minute`);
-      return;
+  making = Promise.resolve();
+  log;
+  health;
+  /** The harness's agents in Chips as last listed: whose context and window copies are sent. */
+  listed = [];
+  /** The agents' context files (Chips ADR 0134), when the bridge knows where Hermes keeps them. */
+  contexts;
+  contextTimer;
+  /** The agents' context windows (Chips ADR 0146), when Hermes's webhook has somewhere to reach. */
+  fills;
+  /** The port Hermes's webhook reaches the bridge on, once it listens. */
+  fillsPort;
+  toldNoReadings = false;
+  /** Whether the log has said once that a model copy wasn't sent. */
+  toldModels = false;
+  /** While Hermes's gateway restarts (Chips ADR 0094), the health watch says nothing: the restart says how it went. */
+  held = false;
+  /** What went wrong in the last restart, said in place of the watch's own words while Hermes doesn't answer. */
+  why;
+  /** Register the agents, start hearing what is said to them, and say how their gateways are. */
+  async start() {
+    const { chips: chips2 } = this.options;
+    const known = await chips2.agents.list();
+    for (const [index, config3] of this.options.agents.entries()) {
+      const key = keyOf(config3);
+      const registered = index === 0 ? await this.seatMain(config3, known) : await chips2.agents.register({ key, name: config3.name });
+      const client = this.options.clientFor?.(config3) ?? new HermesClient(config3.address);
+      this.agents.push({ config: config3, key, client, agentId: registered.agentId, up: true });
     }
-    const original = await this.profileOf(fork.agent_id);
-    if (original === void 0) {
-      this.log(`no copy of ${fork.agent_id}: it isn't one of this harness's agents`);
-      return;
+    for (const [agentId2, profile] of Object.entries(this.options.state.made ?? {})) {
+      const running = this.runningOn(agentId2, profile, known.find((agent) => agent.agentId === agentId2)?.name ?? profile);
+      if (running !== void 0) this.own.set(agentId2, running);
     }
-    const name2 = await this.nameOf(fork.agent_id, original.config.name);
-    const key = `hermes:fork:${fork.id}`;
-    const who = fork.agent_id === original.agentId ? original.key : fork.agent_id;
-    const listed = await chips2.agents.list().catch(() => []);
-    const room = listed.find((agent) => agent.agentId === fork.agent_id)?.room ?? void 0;
-    const from = (room === void 0 ? void 0 : state2.sessions[`${who}|${room}`]) ?? Object.entries(state2.sessions).findLast(([id2]) => id2.startsWith(`${who}|`))?.[1];
-    if (from === void 0) this.log(`${name2} never spoke: its copy remembers nothing`);
-    const session = from === void 0 ? void 0 : await original.client.forkSession(from, { id: `chips-fork-${fork.id}`, title: `Chips space ${spaceId} \xB7 ${key}` });
-    const folder2 = this.folderOf(original, fork.agent_id, name2);
-    const copy = await chips2.agents.register({ key, name: forkName(name2), forkedFrom: fork.agent_id, spaceId });
-    if (session !== void 0) state2.sessions[`${copy.agentId}|${spaceId}`] ??= session;
-    state2.profiles = { ...state2.profiles, [copy.agentId]: original.key };
-    if (folder2 !== void 0) state2.folders = { ...state2.folders, [copy.agentId]: folder2 };
-    this.options.saveState(state2);
-    this.ours.add(copy.agentId);
-    this.names.set(copy.agentId, copy.name);
-    const away = copy.attached === false && !copy.spaces.includes(spaceId);
-    this.log(`${copy.name}, a copy of ${name2}, made${away ? `, not in the room: ${copy.why ?? "too late"}` : ""}`);
-    void this.agentsMoved();
+    this.ours = /* @__PURE__ */ new Set([...known.map((agent) => agent.agentId), ...this.agents.map((agent) => agent.agentId)]);
+    chips2.on("message.new", (message) => void this.hear(message));
+    chips2.on("agent.asked", (asked) => {
+      this.making = this.making.then(() => this.make(asked)).catch((error62) => this.log(`a new agent went wrong: ${messageOf3(error62)}`));
+    });
+    chips2.on("agent.fork", (fork) => {
+      this.making = this.making.then(() => this.copy(fork)).catch((error62) => this.log(`a copy went wrong: ${messageOf3(error62)}`));
+    });
+    chips2.onSpaceAsked((asked) => {
+      this.making = this.making.then(() => this.claim(asked)).catch((error62) => this.log(`a space from the + went wrong: ${messageOf3(error62)}`));
+    });
+    chips2.on("feedback", (feedback2) => {
+      this.notRight(feedback2).catch((error62) => this.log(`a note on a reply went wrong: ${messageOf3(error62)}`));
+    });
+    chips2.on("agent.attached", () => void this.agentsMoved());
+    chips2.on("agent.released", () => void this.agentsMoved());
+    await this.sayHowItIs();
+    this.health = setInterval(() => void this.sayHowItIs(), this.options.healthEveryMs ?? 3e4);
+    this.health.unref();
+    await this.startSettings();
   }
-  /** An agent's name, from Chips's list when it isn't known yet. */
-  async nameOf(agentId2, otherwise) {
-    if (!this.names.has(agentId2)) {
-      const listed = await this.options.chips.agents.list().catch(() => []);
-      for (const agent of listed) this.names.set(agent.agentId, agent.name);
-    }
-    return this.names.get(agentId2) ?? otherwise;
+  /** Hold the health watch's words while Hermes's gateway restarts, and let them go after. */
+  hold(held) {
+    this.held = held;
   }
   /**
-   * The folder an agent works in and sends its files from: the one the config names for them all
-   * (`folder`, as it was), else one of its own under `folders`, named after it the first time it
-   * takes a turn and kept, so a rename keeps it. Every agent once shared one folder, and a team's
-   * files overwrote a one-agent room's game (Chips TT-16); and the one folder had to be Hermes's
-   * own working folder, which a plain Hermes doesn't set (the setup audit, 17 October 2026).
+   * How a restart went (Chips ADR 0094): fine as the gateways now are, or its words, which stand
+   * while Hermes doesn't answer. The health watch speaks for itself again after.
    */
-  folderOf(agent, agentId2, name2) {
-    if (agent.config.folder !== void 0) return agent.config.folder;
-    const { folders: root2, state: state2 } = this.options;
-    if (root2 === void 0) return void 0;
-    const kept = state2.folders?.[agentId2];
-    const folder2 = kept ?? freeFolder(root2, name2, Object.values(state2.folders ?? {}));
-    mkdirSync5(folder2, { recursive: true });
-    if (kept === void 0) {
-      state2.folders = { ...state2.folders, [agentId2]: folder2 };
-      this.options.saveState(state2);
-    }
-    return folder2;
+  async restarted(trouble) {
+    this.held = false;
+    this.why = trouble;
+    if (trouble === void 0) return this.sayHowItIs();
+    await this.options.chips.reportTrouble(trouble).catch(() => void 0);
+  }
+  stop() {
+    if (this.health !== void 0) clearInterval(this.health);
+    if (this.contextTimer !== void 0) clearInterval(this.contextTimer);
+    void this.fills?.close();
   }
+  // ------------------------------------------------------------------ an agent's page
   /**
-   * The room's project for a turn (Chips ADR 0221): the agent's copy, in its folder, brought up to
-   * date, and what the turn is told of it. None for an agent a person pointed at a folder of their
-   * own, nor where this machine has no git for it.
+   * The agents' models, context and context windows, sent at start and kept current: the models
+   * again when an agent comes or goes, the files read again every so often and after each turn, a
+   * window copy on each reading Hermes sends.
    */
-  async projectFor(turn, spaceId, agentId2, name2) {
-    if (this.options.projects !== true || turn.agent.config.folder !== void 0) return void 0;
-    const folder2 = turn.folder;
-    if (folder2 === void 0) return void 0;
+  async startSettings() {
+    this.listed = await this.options.chips.agents.list().catch(() => this.listed);
+    await this.sendModels();
+    if (this.contexts === void 0) return;
+    await this.contexts.refresh();
+    this.contextTimer = setInterval(() => void this.contexts?.refresh(), this.options.contextEveryMs ?? 15e3);
+    this.contextTimer.unref();
+    const fills2 = this.fills;
+    const asked = this.options.fills;
+    if (fills2 === void 0 || asked === void 0) return;
+    const kept = this.options.state.fills ??= {};
     try {
-      const project = this.options.chips.project({ spaceId, agentId: agentId2, name: name2, folder: folder2, log: (line2) => this.log(line2) });
-      const facts = await project.pull();
-      turn.project = { copy: project, name: name2 };
-      return facts;
+      this.fillsPort = await fills2.listen(asked.port);
+      if (kept.port !== this.fillsPort) {
+        kept.port = this.fillsPort;
+        this.options.saveState(this.options.state);
+      }
     } catch (error62) {
-      this.log(`${name2}'s copy of the room's project couldn't be readied: ${messageOf2(error62)}`);
-      return void 0;
+      this.log(`context window: nothing can listen on port ${asked.port} (${messageOf3(error62)}), so Chips won't show how full each agent's context is`);
     }
+    await fills2.sendAll();
   }
-  /**
-   * What the turn changed in its copy, sent to the room's project before its words are posted: the
-   * commit it left `main` at, for the reply to carry (Chips ADR 0222), when it sent one; else, when
-   * the change didn't go, the line the reply says so in (Chips AP-6).
-   */
-  async sendProject(turn, words4) {
-    if (turn.project === void 0) return {};
-    const { copy, name: name2 } = turn.project;
-    try {
-      const pushed = await copy.push({ words: words4 });
-      this.log(`${name2}'s project: ${pushedInWords(pushed)}`);
-      if (pushed.state === "sent") return { change: pushed.commit };
-      const note = heldNote(pushed, name2);
-      return note === void 0 ? {} : { note };
-    } catch (error62) {
-      this.log(`${name2}'s project couldn't be sent: ${messageOf2(error62)}`);
-      const note = heldNote({ state: "failed", why: messageOf2(error62) }, name2);
-      return note === void 0 ? {} : { note };
+  /** The address Hermes's webhook POSTs a profile's readings to, once the bridge listens. */
+  hookUrl(profile = "default") {
+    return this.fillsPort === void 0 ? void 0 : hookUrl(this.fillsPort, profileName(profile));
+  }
+  /** The harness's agents listed again, the copies of any gone forgotten, and the context and models sent. */
+  async agentsMoved() {
+    const before = this.listed;
+    this.listed = await this.options.chips.agents.list().catch(() => this.listed);
+    const now = new Set(this.active().map((agent) => agent.agentId));
+    for (const gone of before) {
+      if (now.has(gone.agentId)) continue;
+      this.options.chips.settings.forget(gone.agentId);
+      this.fills?.forget(gone.agentId);
     }
+    await this.contexts?.refresh();
+    await this.sendModels();
+  }
+  /** The harness's agents that read anything now: the active ones listed. */
+  active() {
+    return this.listed.filter((agent) => agent.state === "active");
+  }
+  /** A profile as the context needs it: its name and its home under Hermes's root. */
+  profileOfRunning(agent) {
+    const root2 = this.options.hermesRoot;
+    if (root2 === void 0) return void 0;
+    return { name: profileName(agent.config.address.profile), home: profileHome(root2, agent.config.address.profile) };
+  }
+  /** The profile an agent runs on: its own, a copy's original's, else the first (as `profileOf` picks). */
+  profileFor(agentId2) {
+    const running = this.runningFor(agentId2);
+    return running === void 0 ? void 0 : this.profileOfRunning(running);
   }
-  /** Trouble while a profile's gateway doesn't answer, and fine once all do (ADR 0083); nothing while a restart runs. */
-  async sayHowItIs() {
-    if (this.held) return;
-    for (const agent of this.agents) agent.up = await agent.client.healthy();
-    if (this.held) return;
-    const down = this.agents.filter((agent) => !agent.up);
-    if (down.length === 0) this.why = void 0;
-    const chips2 = this.options.chips;
-    const said2 = down.length === 0 ? chips2.reportOk() : chips2.reportTrouble(this.why ?? `Hermes isn't answering for ${down.map((agent) => agent.config.name).join(", ")}`);
-    await said2.catch(() => void 0);
+  /** What answers for an agent: its own profile, a copy's original's, else the first. */
+  runningFor(agentId2) {
+    const own2 = this.agents.find((agent) => agent.agentId === agentId2) ?? this.own.get(agentId2);
+    const copied = this.options.state.profiles?.[agentId2];
+    return own2 ?? (copied === void 0 ? void 0 : this.byKey(copied)) ?? this.agents[0];
   }
-  // ------------------------------------------------------------------ what is said to it
-  /** A message for some of its agents: each takes a turn in its room, one after another there. */
-  async hear(message, how = {}) {
-    const spaceId = message.space_id;
-    if (spaceId === void 0) return;
-    const harnessId = this.options.chips.harnessId;
-    for (const taker of message.for ?? [harnessId]) {
-      const agent = await this.runnerOf(taker);
-      if (agent === void 0) continue;
-      const room = this.roomOf(agent, taker, spaceId);
-      room.queue.push({ message, speakerId: taker === harnessId ? void 0 : taker, ...how });
-      void this.pump(room);
-    }
+  /** A profile the bridge speaks to, by its key: a configured agent's, or a made agent's Chips id. */
+  byKey(key) {
+    return this.agents.find((agent) => agent.key === key) ?? this.own.get(key);
   }
   /**
-   * "Not right?" on one of its agents' replies (Chips ADR 0200): a person's note on it, or a bare
-   * 👎 from an older phone, is a turn of the agent that said it, in its session in that room and
-   * in line with the room's other turns, to look again and answer in its place. Any other
-   * reaction is the person's own. Once per event, however often it is heard.
+   * Who reads what: each active agent with its profile, and the first profile, whose SOUL.md each
+   * new agent starts from (and whose every file each new agent reads, where none gets a profile of
+   * its own).
    */
-  async notRight(feedback2) {
-    const { space_id: spaceId, message_id: messageId } = feedback2;
-    const note = feedback2.kind === "correction" ? (feedback2.text ?? "").trim() : void 0;
-    const flagged = note === void 0 ? feedback2.kind === "reaction" && feedback2.reaction === "\u{1F44E}" : note !== "";
-    if (spaceId === void 0 || !messageId || !flagged || this.lookedAt.has(feedback2.id)) return;
-    this.lookedAt.add(feedback2.id);
-    for (const old of this.lookedAt) {
-      if (this.lookedAt.size <= KEPT_FEEDBACK) break;
-      this.lookedAt.delete(old);
+  roster() {
+    const readers = [];
+    const ids2 = /* @__PURE__ */ new Set([...this.active().map((agent) => agent.agentId), ...this.agents.map((agent) => agent.agentId)]);
+    for (const agentId2 of ids2) {
+      if (this.listed.some((agent) => agent.agentId === agentId2 && agent.state !== "active")) continue;
+      const profile = this.profileFor(agentId2);
+      if (profile !== void 0) readers.push({ agentId: agentId2, profile });
     }
-    const context = await this.options.chips.roomContext(spaceId, { limit: 200 }).catch(() => void 0);
-    const line2 = context?.lines.find((each) => each.message_id === messageId);
-    const message = {
-      type: "message.new",
-      space_id: spaceId,
-      // An id of its own, so nothing of the turn is taken for the reply's.
-      message_id: messageIdOf(feedback2.id),
-      text: lookAgain(feedback2.from.display_name, line2?.text, note),
-      from: feedback2.from,
-      ...line2 === void 0 ? {} : { for: [line2.from.id] }
+    const first = this.agents[0];
+    return {
+      readers,
+      first: first === void 0 ? void 0 : this.profileOfRunning(first),
+      ownProfiles: this.options.profiles !== void 0
     };
-    await this.hear(message, { goal: lookingAgain(note), sayWho: false });
   }
+  /** The agent a Hermes session the bridge keeps is, with its profile: nothing for any other. */
+  whoseSession(sessionId) {
+    const entry = Object.entries(this.options.state.sessions).find(([, session]) => session === sessionId);
+    if (entry === void 0) return void 0;
+    const who = entry[0].slice(0, entry[0].lastIndexOf("|"));
+    const agentId2 = this.agents.find((agent) => agent.key === who)?.agentId ?? who;
+    const profile = this.profileFor(agentId2);
+    return profile === void 0 ? void 0 : { agentId: agentId2, profile: profile.name, home: profile.home };
+  }
+  /** A person's edit of a context file from Chips (Chips ADR 0134), saved and answered. */
+  async onContextEdit(frame) {
+    if (this.contexts === void 0) throw new Refuse("This bridge reads no context files.");
+    if (frame.agent_id !== void 0 && !this.listed.some((agent) => agent.agentId === frame.agent_id)) {
+      this.listed = await this.options.chips.agents.list().catch(() => this.listed);
+    }
+    return this.contexts.edit(frame);
+  }
+  // ------------------------------------------------------------------ an agent's model
   /**
-   * Which profile answers for a Chips agent, as `profileOf` says. An agent not known yet may be a
-   * copy being made, which is waited for, so that its first message is answered in its session.
+   * The model a person picked for an agent, as its copy names it: a choice's id, or the model its
+   * config says each of its profile's runs asks for; nothing for Hermes's default.
    */
-  async runnerOf(taker) {
-    if (taker !== this.options.chips.harnessId && !this.ours.has(taker)) await this.copying;
-    return this.profileOf(taker);
+  ownModel(agentId2, running) {
+    const picked = this.options.state.models?.[agentId2];
+    return picked === null ? void 0 : picked ?? running.config.model;
+  }
+  /** What a turn's runs ask Hermes for: the agent's own model, else nothing, and the profile's runs. */
+  runModel(turn) {
+    const picked = this.options.state.models?.[turn.who];
+    if (picked === null) return {};
+    if (picked !== void 0) return runModelOf(picked);
+    return turn.agent.config.model === void 0 ? {} : { model: turn.agent.config.model };
   }
   /**
-   * Which profile answers for a Chips agent: its own; a copy's original's; or the first for the
-   * harness itself and for any other of the harness's — its default agent, one Chips made since —
-   * read afresh once when a name is new.
+   * Each agent's model, sent to Chips (Chips ADR 0141): the models Hermes has for its profile, read
+   * once a profile, with the one it runs on. One whose Hermes doesn't answer is sent none, and the
+   * log says so once.
    */
-  async profileOf(taker) {
-    const own2 = this.agents.find((agent) => agent.agentId === taker);
-    if (own2 !== void 0) return own2;
-    const copied = this.options.state.profiles?.[taker];
-    const original = this.agents.find((agent) => copied !== void 0 && agent.key === copied);
-    if (original !== void 0) return original;
-    if (taker !== this.options.chips.harnessId && !this.ours.has(taker)) {
-      const listed = await this.options.chips.agents.list().catch(() => []);
-      for (const agent of listed) {
-        this.ours.add(agent.agentId);
-        this.names.set(agent.agentId, agent.name);
+  async sendModels() {
+    const { chips: chips2 } = this.options;
+    const ids2 = /* @__PURE__ */ new Set([...this.active().map((agent) => agent.agentId), ...this.agents.map((agent) => agent.agentId)]);
+    const read = /* @__PURE__ */ new Map();
+    for (const agentId2 of ids2) {
+      const running = this.runningFor(agentId2);
+      if (running === void 0) continue;
+      try {
+        let options = read.get(running);
+        if (options === void 0) {
+          options = running.client.modelOptions();
+          read.set(running, options);
+        }
+        const copy = copyOf(await options, this.ownModel(agentId2, running));
+        if (copy !== void 0) await chips2.settings.model(agentId2, copy);
+      } catch (error62) {
+        if (!this.toldModels) this.log(`models: none sent for ${running.config.name}: ${messageOf3(error62)}`);
+        this.toldModels = true;
       }
     }
-    return taker === this.options.chips.harnessId || this.ours.has(taker) ? this.agents[0] : void 0;
   }
   /**
-   * The session a turn is taken in: the profile's own in the room, for its agent or the harness
-   * itself, and one of its own for any other of the harness's, so two in a room are two.
+   * A person picked an agent's model (Chips ADR 0141): one Hermes has for its profile, kept as the
+   * model each of its runs asks for from now on, or Hermes's default (`null`), the profile's own.
+   * The model it runs on already changes nothing. Hermes says no levels of effort, so none is taken.
    */
-  roomOf(agent, taker, spaceId) {
-    const own2 = taker === agent.agentId || taker === this.options.chips.harnessId;
-    const id2 = `${own2 ? agent.key : taker}|${spaceId}`;
-    let room = this.rooms.get(id2);
-    if (room === void 0) {
-      room = { id: id2, agent, spaceId, queue: [], busy: false };
-      this.rooms.set(id2, room);
-    }
-    return room;
-  }
-  async pump(room) {
-    if (room.busy) return;
-    const asked = room.queue.shift();
-    if (asked === void 0) return;
-    room.busy = true;
-    try {
-      await this.turn(room, asked);
-    } catch (error62) {
-      this.log(`a turn of ${room.agent.config.name} went wrong: ${messageOf2(error62)}`);
-    } finally {
-      room.busy = false;
-      void this.contexts?.refresh();
-      void this.pump(room);
-    }
-  }
-  async turn(room, { message, speakerId, goal, sayWho }) {
-    const { agent, spaceId } = room;
-    const speaker = speakerId === void 0 ? this.options.chips : this.options.chips.as(speakerId);
-    const run2 = await speaker.runs.start({ spaceId, goal: goal ?? goalOf(message, agent.config.name) });
-    const turn = {
-      run: run2,
-      speaker,
-      agent,
-      hermesRun: "",
-      reply: "",
-      saidAt: 0,
-      cancelled: false,
-      next: [],
-      open: /* @__PURE__ */ new Map(),
-      counted: 0,
-      approvals: /* @__PURE__ */ new Map(),
-      allowed: [],
-      interrupted: false
-    };
-    run2.on("cancel", () => {
-      turn.cancelled = true;
-      if (turn.hermesRun !== "") void agent.client.stop(turn.hermesRun).catch(() => void 0);
-    });
-    run2.on("steer", (steer) => {
-      const words4 = `${steer.from?.display_name ?? "The person"} adds: ${steer.text}`;
-      void this.steered(turn, words4, steer.mode);
-    });
-    let session;
+  async onModelChange(frame) {
+    const { state: state2 } = this.options;
+    const agentId2 = frame.agent_id;
+    const ours2 = this.ours.has(agentId2) || this.agents.some((agent) => agent.agentId === agentId2) || this.own.has(agentId2);
+    const running = ours2 ? this.runningFor(agentId2) : void 0;
+    if (running === void 0) throw new Refuse(`${agentId2} isn't one of this harness's agents.`);
+    let options;
     try {
-      session = await this.sessionFor(room);
+      options = await running.client.modelOptions();
     } catch (error62) {
-      await this.failed(turn, `${agent.config.name} couldn't open a session in Hermes: ${messageOf2(error62)}`, true);
-      return;
+      throw new Refuse(`Hermes didn't say which models it has: ${messageOf3(error62)}`);
     }
-    const name2 = speakerId === void 0 ? agent.config.name : await this.nameOf(speakerId, agent.config.name);
-    turn.folder = this.folderOf(agent, speakerId ?? agent.agentId, name2);
-    const project = await this.projectFor(turn, room.spaceId, speakerId ?? agent.agentId, name2);
-    let text = promptFor(message, { taker: speakerId, sayWho, project });
-    for (let round = 0; text !== void 0 && !turn.cancelled && !run2.over; round += 1) {
-      const last = await this.once(turn, session, text, `${run2.id}:${round}`);
-      if (last === void 0) return;
-      if (last.event === "run.cancelled" && turn.interrupted && turn.next.length > 0) {
-        turn.interrupted = false;
-        text = turn.next.shift();
-        continue;
-      }
-      if (last.event !== "run.completed") {
-        await this.ended(turn, last);
-        return;
-      }
-      text = turn.next.shift();
-      if (text === void 0) await this.finish(turn, last);
+    const now = copyOf(options, this.ownModel(agentId2, running));
+    if (now === void 0) throw new Refuse("Hermes has no model for this agent's profile.");
+    if (frame.model === now.model) return now;
+    if (frame.model !== null && !now.choices.some((choice) => choice.id === frame.model)) {
+      throw new Refuse(`Hermes has no ${frame.model} for this agent's profile.`, now);
     }
+    state2.models = { ...state2.models, [agentId2]: frame.model };
+    this.options.saveState(state2);
+    const name2 = await this.nameOf(agentId2, running.config.name);
+    this.log(`${name2} runs on ${frame.model ?? `Hermes's default (${now.default?.model ?? "its profile's"})`}, from Chips`);
+    return copyOf(options, this.ownModel(agentId2, running)) ?? now;
   }
-  /** One Hermes run of the turn: started, its events heard to the end. The end, or nothing on failure. */
-  async once(turn, session, text, key) {
-    const { agent } = turn;
-    try {
-      turn.hermesRun = await agent.client.startRun({ text, sessionId: session, model: agent.config.model, key, instructions: instructionsFor(turn.folder, turn.project !== void 0) });
-    } catch (error62) {
-      await this.failed(turn, `${agent.config.name} couldn't start in Hermes: ${messageOf2(error62)}`, true);
-      return void 0;
+  /** A person's Compact now (Chips ADR 0146): Hermes can't be asked to compact from outside a run. */
+  onWindowCompact(frame) {
+    throw new Refuse(WHY_NOT, this.fills?.copyOf(frame.agent_id));
+  }
+  /** A person's limit (Chips ADR 0146): Hermes sets it in its profile's config, for all its agents. */
+  onWindowChange(frame) {
+    const profile = this.profileFor(frame.agent_id);
+    throw new Refuse(whyReadOnly(profile?.name ?? "default"), this.fills?.copyOf(frame.agent_id));
+  }
+  /** The Main agent, the first registered, once started: who says the harness's first words. */
+  get mainAgentId() {
+    return this.agents[0]?.agentId;
+  }
+  /**
+   * The Main agent: the one Chips made for the harness when it joined, keyed by the harness's own
+   * id, registered as Main (Chips ADR 0183), so it is called what the config says and has no
+   * second beside it. It goes home, and a Main of ours from before that, out of its room now, is
+   * archived, which gives its name up. With no such agent (a harness from before them), the Main
+   * Chips has is kept: a harness has one at most.
+   */
+  async seatMain(config3, known) {
+    const { chips: chips2 } = this.options;
+    const before = known.find((agent) => agent.lead);
+    const made = known.some((agent) => agent.key === chips2.harnessId);
+    if (!made && before !== void 0) {
+      await this.goHome(before, known);
+      return before;
     }
-    if (turn.cancelled) await agent.client.stop(turn.hermesRun).catch(() => void 0);
-    try {
-      const last = await agent.client.events(turn.hermesRun, (event) => this.heard(turn, event));
-      return last ?? await this.endOf(turn);
-    } catch (error62) {
-      this.log(`lost ${agent.config.name}'s run ${turn.hermesRun}: ${messageOf2(error62)}`);
-      return await this.endOf(turn);
+    const main2 = await chips2.agents.register({ key: chips2.harnessId, name: config3.name, lead: true });
+    await this.goHome(main2, known);
+    if (before !== void 0 && before.agentId !== main2.agentId) {
+      await chips2.agents.register({ key: before.key, name: before.name, state: "archived" }).catch((error62) => this.log(`${before.name} stays: ${String(error62)}`));
     }
+    return main2;
   }
-  /** The end of a run whose stream was lost: its state read until it is over, as a terminal event. */
-  async endOf(turn) {
-    const by = Date.now() + LOST_STREAM_MS;
-    while (Date.now() < by) {
-      const state2 = await turn.agent.client.run(turn.hermesRun).catch(() => void 0);
-      const status = typeof state2?.["status"] === "string" ? state2["status"] : void 0;
-      if (status !== void 0 && TERMINAL.has(`run.${status}`)) {
-        return { ...state2, event: `run.${status}` };
-      }
-      await new Promise((resolve7) => setTimeout(resolve7, 1e3));
-    }
-    await this.failed(turn, `${turn.agent.config.name}'s run in Hermes stopped answering.`, true);
-    return void 0;
+  /** The Main agent into the harness's own room, in the place of whichever of ours is there. */
+  async goHome(main2, known) {
+    const { chips: chips2, home: home2 } = this.options;
+    if (home2 === void 0 || main2.spaces.includes(home2)) return;
+    const there = known.find((agent) => agent.agentId !== main2.agentId && agent.spaces.includes(home2));
+    await chips2.agents.attach(main2.agentId, { spaceId: home2, replacing: there?.agentId ?? chips2.harnessId }).catch((error62) => this.log(`${main2.name} stays out of its home: ${String(error62)}`));
   }
-  /** The room's session: the one it had, or a new one Hermes makes for it. */
-  async sessionFor({ id: id2, agent, spaceId }) {
-    const kept = this.options.state.sessions[id2];
-    if (kept !== void 0) return kept;
-    const who = id2.slice(0, id2.lastIndexOf("|"));
-    const made = await agent.client.newSession(`Chips space ${spaceId}${who === agent.key ? "" : ` \xB7 ${who}`}`);
-    this.options.state.sessions[id2] = made;
-    this.options.saveState(this.options.state);
-    return made;
+  /**
+   * A person asked for a new agent in a room (Chips ADR 0108): one of the harness's, keyed by the
+   * ask so an ask heard twice makes one, registered for the room, which Chips puts it in while the
+   * room waits. It answers through a Hermes profile of its own (`ownProfile`).
+   */
+  async make(asked) {
+    const { chips: chips2 } = this.options;
+    if (asked.harness_id !== chips2.harnessId || asked.space_id === void 0) return;
+    const agent = await chips2.agents.register({
+      key: `hermes:asked:${asked.id}`,
+      name: asked.name,
+      madeFor: asked.id,
+      spaceId: asked.space_id
+    });
+    this.names.set(agent.agentId, agent.name);
+    this.log(`${agent.name} made${agent.attached === false ? `, not in the room: ${agent.why ?? "too late"}` : ""}`);
+    await this.ownProfile(agent.agentId, agent.name);
+    this.ours.add(agent.agentId);
+    void this.agentsMoved();
   }
   /**
-   * A person's words for a run that is going. A steer is said to the Hermes run, or to the next one
-   * of the turn when Hermes won't take it now. A follow-up waits for this one to end. An
-   * interrupt stops it, and the turn goes on with the words.
+   * A Hermes profile of its own for an agent made in Chips (Chips ADR 0241), so it remembers only
+   * its own conversations: named after the agent, cloned from the Main agent's profile so it starts
+   * with its model, keys, tools, skills and SOUL.md, its memory empty (`profiles.ts`). The gateway
+   * is asked to serve it now; one that serves only the profile it started with, as Hermes's does
+   * when it started with one, is restarted once. Where Hermes doesn't make one, the agent runs on
+   * the first profile, in a session of its own, and the log says why.
    */
-  async steered(turn, text, mode) {
-    if (mode === "interrupt" && turn.hermesRun !== "") {
-      turn.next.unshift(text);
-      turn.interrupted = true;
-      await turn.agent.client.stop(turn.hermesRun).catch(() => void 0);
+  async ownProfile(agentId2, name2) {
+    const { profiles, hermesRoot: root2, state: state2 } = this.options;
+    const main2 = this.agents[0];
+    if (profiles === void 0 || root2 === void 0 || main2 === void 0 || this.own.has(agentId2)) return;
+    const from = profileName(main2.config.address.profile);
+    const profile = freeProfile(root2, name2, Object.values(state2.made ?? {}));
+    const home2 = profileHome(root2, profile);
+    const secret = state2.fills?.secret ?? this.options.fills?.secret;
+    try {
+      await profiles.create(profile, from);
+      const port = this.fillsPort;
+      const hook = readyProfile(home2, { from, profile }, port === void 0 || secret === void 0 ? void 0 : { port, secret });
+      if (hook?.state === "by_hand") this.log(`context window: ${hook.path} was left as it is: ${hook.why}. Add these lines to it:
+${hook.lines}`);
+    } catch (error62) {
+      this.log(`${name2} runs on the ${from} profile, in a session of its own: Hermes didn't make it one (${messageOf3(error62)})`);
       return;
     }
-    if (mode === "steer" && turn.hermesRun !== "") {
-      try {
-        await turn.agent.client.steer(turn.hermesRun, text);
-        return;
-      } catch (error62) {
-        this.log(`Hermes didn't take a steer mid-run (${messageOf2(error62)}); saying it next`);
-      }
+    state2.made = { ...state2.made, [agentId2]: profile };
+    this.options.saveState(state2);
+    const running = this.runningOn(agentId2, profile, name2);
+    if (running !== void 0) this.own.set(agentId2, running);
+    this.log(`${name2} has a Hermes profile of its own, ${profile}, cloned from ${from}`);
+    const served = await profiles.serve().catch(() => void 0);
+    if (served === false) {
+      this.log(`Hermes's gateway serves only the profile it started with, as it does when there was one: restarting it once, so it serves ${profile} too`);
+      await this.options.restartGateway?.();
+    } else if (served === void 0) {
+      this.log(`Hermes's gateway didn't answer on its control socket: it serves ${profile} once it looks again, or starts again`);
     }
-    turn.next.push(text);
   }
-  // ------------------------------------------------------------------ what Hermes streams
-  async heard(turn, event) {
-    if (turn.run.over) return;
-    switch (event.event) {
-      case "message.delta":
-        turn.reply += typeof event["delta"] === "string" ? event["delta"] : "";
-        return;
-      case "message.interim":
-      case "reasoning.available":
-        this.sayThought(turn, String(event["text"] ?? ""), event.event === "message.interim" ? "writing" : "thinking");
-        return;
-      case "tool.started":
-      case "subagent.start":
-        await this.started(turn, event);
-        return;
-      case "tool.completed":
-      case "subagent.complete":
-        await this.completed(turn, event);
-        return;
-      case "approval.request":
-        void this.ask(turn, event);
-        return;
-      case "approval.responded":
-        await this.settled(turn, event);
-        return;
-      default:
-        return;
-    }
+  /**
+   * A profile made for an agent, as the bridge reaches it: under `/p/<profile>` of the gateway the
+   * Main agent is reached at, with the key in the profile's own `.env`.
+   */
+  runningOn(agentId2, profile, name2) {
+    const main2 = this.agents[0];
+    const root2 = this.options.hermesRoot;
+    if (main2 === void 0 || root2 === void 0) return void 0;
+    const home2 = profileHome(root2, profile);
+    const config3 = {
+      name: name2,
+      address: { url: main2.config.address.url, profile, key: envValue(home2, KEY_ENV) ?? "" },
+      keyEnv: KEY_ENV,
+      keyFrom: join10(home2, ".env")
+    };
+    const client = this.options.clientFor?.(config3) ?? new HermesClient(config3.address);
+    return { config: config3, key: agentId2, client, agentId: agentId2, up: true };
   }
-  sayThought(turn, text, phase) {
-    const now = Date.now();
-    const line2 = lastLine(text);
-    if (line2 === "" || now - turn.saidAt < QUIET_MS) return;
-    turn.saidAt = now;
-    void turn.run.status({ phase, verbPhrase: line2.slice(0, 200) }).catch(() => void 0);
+  /**
+   * A space a person asked the harness for from the + (Chips ADR 0241), as the ACP bridge takes
+   * one: claimed under a key made from the space, so a space handed over twice is claimed once,
+   * and named from its first words. Chips makes the agent of that key and puts it in the space; it
+   * gets a Hermes profile of its own (`ownProfile`). It answers the first words, which are the
+   * ask's and aren't heard again.
+   */
+  async claim(asked) {
+    const { chips: chips2 } = this.options;
+    const { spaceId, firstMessage } = asked;
+    const key = `hermes:space:${spaceId}`;
+    await chips2.claimSpace(spaceId, key, titleFrom(firstMessage.text));
+    const agent = (await chips2.agents.list()).find((each) => each.key === key);
+    if (agent === void 0) {
+      this.log(`claimed ${spaceId}, and Chips put no agent there`);
+      return;
+    }
+    this.names.set(agent.agentId, agent.name);
+    this.log(`${agent.name} claimed ${spaceId}`);
+    await this.ownProfile(agent.agentId, agent.name);
+    this.ours.add(agent.agentId);
+    void this.agentsMoved();
+    const message = {
+      type: "message.new",
+      space_id: spaceId,
+      message_id: firstMessage.messageId,
+      text: firstMessage.text,
+      from: { participant_id: asked.askedBy, kind: "person", display_name: await this.whoSaid(asked), role: "member" },
+      for: [agent.agentId]
+    };
+    void this.hear(message);
   }
-  async started(turn, event) {
-    const sub = event.event === "subagent.start";
-    const tool = sub ? "delegate_task" : String(event["tool"] ?? "tool");
-    turn.counted += 1;
-    const callId = typeof event["tool_call_id"] === "string" ? event["tool_call_id"] : void 0;
-    const stepId = callId ?? `${tool}-${turn.counted}`;
-    const lane = callId ?? (sub ? "subagent" : `tool:${tool}`);
-    turn.open.set(lane, [...turn.open.get(lane) ?? [], stepId]);
-    const said2 = sub ? event["goal"] : event["preview"];
-    await turn.run.step({
-      stepId,
-      status: "started",
-      title: `${tool}${typeof said2 === "string" && said2 !== "" ? ` \xB7 ${said2}` : ""}`.slice(0, 300),
-      tool,
-      ...KINDS[tool] === void 0 ? {} : { kind: KINDS[tool] }
-    }).catch(() => void 0);
+  /** Who said a space's first words, from its lines. */
+  async whoSaid(asked) {
+    const context = await this.options.chips.roomContext(asked.spaceId, { limit: 20 }).catch(() => void 0);
+    return context?.lines.find((line2) => line2.message_id === asked.firstMessage.messageId)?.from.name ?? "Someone";
   }
-  async completed(turn, event) {
-    const sub = event.event === "subagent.complete";
-    const tool = sub ? "delegate_task" : String(event["tool"] ?? "tool");
-    const callId = typeof event["tool_call_id"] === "string" ? event["tool_call_id"] : void 0;
-    const lane = callId ?? (sub ? "subagent" : `tool:${tool}`);
-    const waiting = turn.open.get(lane) ?? [];
-    const stepId = callId ?? waiting.shift() ?? `${tool}-${turn.counted += 1}`;
-    turn.open.set(lane, waiting.filter((each) => each !== stepId));
-    const failed = event["error"] === true || sub && event["status"] === "failed";
-    const approvalId = sub ? void 0 : turn.allowed.shift();
-    if (approvalId !== void 0) {
-      await turn.run.executed(approvalId, failed ? "failed" : "executed").catch(() => void 0);
+  /**
+   * A person asked for a copy of one of the harness's agents in another room (ADR 0087, Fork): the
+   * agent's session in the room it is in, else the last it had, forked in Hermes, is the copy's
+   * session in the room asked. The copy answers through its original's profile, whose Hermes has
+   * that session (Hermes forks a session only within its profile, so a copy gets no profile of its
+   * own: Chips ADR 0241), and works in its original's folder. It is registered with `forkedFrom` for the
+   * room, which Chips puts it in while the room waits. The fork and the copy are keyed by the ask,
+   * so an ask heard twice forks once (Hermes refuses the id again) and registers the same copy. An
+   * agent that never spoke is copied with nothing to remember. A turn still going is not in the
+   * copy: Hermes copies what the session holds. Nothing is made for an ask the room has stopped
+   * waiting for (`FORK_WAIT_MS`), nor for an agent that isn't the harness's.
+   */
+  async copy(fork) {
+    const { chips: chips2, state: state2 } = this.options;
+    const spaceId = fork.space_id;
+    if (spaceId === void 0) return;
+    const late = Date.now() - Date.parse(fork.ts);
+    if (late > FORK_WAIT_MS) {
+      this.log(`no copy of ${fork.agent_id}: asked ${Math.round(late / 1e3)} s ago, and the room waits a minute`);
+      return;
     }
-    const summary = sub ? event["summary"] : resultWords(event["preview"]);
-    const seconds = typeof event["duration"] === "number" ? event["duration"] : void 0;
-    await turn.run.step({
-      stepId,
-      status: failed ? "failed" : "done",
-      tool,
-      ...typeof summary === "string" && summary !== "" ? { summary: summary.slice(0, 2e3) } : {},
-      ...seconds === void 0 ? {} : { durationMs: Math.round(seconds * 1e3) }
-    }).catch(() => void 0);
-    const cost3 = event["cost_usd"];
-    if (sub && typeof cost3 === "number" && cost3 > 0) {
-      const model = typeof event["model"] === "string" ? event["model"] : "subagent";
-      await turn.run.usage({ scope: "step", model, costUsd: cost3 }).catch(() => void 0);
+    const original = await this.profileOf(fork.agent_id);
+    if (original === void 0) {
+      this.log(`no copy of ${fork.agent_id}: it isn't one of this harness's agents`);
+      return;
     }
+    const name2 = await this.nameOf(fork.agent_id, original.config.name);
+    const key = `hermes:fork:${fork.id}`;
+    const who = fork.agent_id === original.agentId ? original.key : fork.agent_id;
+    const listed = await chips2.agents.list().catch(() => []);
+    const room = listed.find((agent) => agent.agentId === fork.agent_id)?.room ?? void 0;
+    const from = (room === void 0 ? void 0 : state2.sessions[`${who}|${room}`]) ?? Object.entries(state2.sessions).findLast(([id2]) => id2.startsWith(`${who}|`))?.[1];
+    if (from === void 0) this.log(`${name2} never spoke: its copy remembers nothing`);
+    const session = from === void 0 ? void 0 : await original.client.forkSession(from, { id: `chips-fork-${fork.id}`, title: `Chips space ${spaceId} \xB7 ${key}` });
+    const folder2 = this.folderOf(original, fork.agent_id, name2);
+    const copy = await chips2.agents.register({ key, name: forkName(name2), forkedFrom: fork.agent_id, spaceId });
+    if (session !== void 0) state2.sessions[`${copy.agentId}|${spaceId}`] ??= session;
+    state2.profiles = { ...state2.profiles, [copy.agentId]: original.key };
+    if (folder2 !== void 0) state2.folders = { ...state2.folders, [copy.agentId]: folder2 };
+    this.options.saveState(state2);
+    this.ours.add(copy.agentId);
+    this.names.set(copy.agentId, copy.name);
+    const away = copy.attached === false && !copy.spaces.includes(spaceId);
+    this.log(`${copy.name}, a copy of ${name2}, made${away ? `, not in the room: ${copy.why ?? "too late"}` : ""}`);
+    void this.agentsMoved();
   }
-  // ------------------------------------------------------------------ what Hermes asks
-  /** An approval Hermes wants before it acts, as a card; the answer is Hermes's choice. */
-  async ask(turn, event) {
-    const requestId = idOf(event);
-    const command = typeof event["command"] === "string" ? event["command"] : void 0;
-    const description = typeof event["description"] === "string" ? event["description"] : void 0;
-    const choices = Array.isArray(event["choices"]) ? event["choices"].map(String) : ["once", "deny"];
-    const approvalId = ids.next("approval");
-    turn.approvals.set(requestId ?? approvalId, { approvalId, answered: false });
-    const asked = turn.run.approval({
-      approvalId,
-      action: {
-        kind: command === void 0 ? "hermes.approval" : "shell.exec",
-        input: { ...command === void 0 ? {} : { command }, ...description === void 0 ? {} : { description } }
-      },
-      question: (description === void 0 ? "Run this command?" : `Allow it to ${lowerFirst(description)}?`).slice(0, 300),
-      lasts: "once",
-      risk: [],
-      ...command === void 0 ? {} : { preview: { format: "markdown", title: "Run a command", body: `\`\`\`sh
-${command}
-\`\`\`` } }
-    });
-    const stopped2 = new Promise((resolve7) => turn.run.on("cancel", () => resolve7(void 0)));
-    const decision = await Promise.race([asked, stopped2]);
-    const pending = turn.approvals.get(requestId ?? approvalId);
-    if (decision === void 0 || pending === void 0 || pending.answered) return;
-    pending.answered = true;
-    if (decision.allowed) turn.allowed.push(approvalId);
-    const generation = event["execution_generation"];
-    await turn.agent.client.approve(turn.hermesRun, {
-      choice: choiceOf(decision, choices, command !== void 0),
-      ...requestId === void 0 ? {} : { request_id: requestId },
-      ...typeof generation === "number" ? { execution_generation: generation } : {}
-    }).catch((error62) => this.log(`Hermes didn't take the answer: ${messageOf2(error62)}`));
-  }
-  /** An approval answered in Hermes's own tools: settled in Chips, once, so the card cools (ADR 0079). */
-  async settled(turn, event) {
-    const requestId = idOf(event);
-    const pending = requestId === void 0 ? void 0 : turn.approvals.get(requestId);
-    if (pending === void 0 || pending.answered) return;
-    pending.answered = true;
-    const denied = event["choice"] === "deny";
-    await this.options.chips.send(
-      "approval.resolved",
-      { run_id: turn.run.id },
-      {
-        approval_id: pending.approvalId,
-        decision: denied ? "denied" : "approved",
-        scope: "once",
-        reason: "Answered in Hermes."
-      },
-      `hermes-approval:${turn.hermesRun}:${requestId}:settled`
-    ).catch(() => void 0);
-  }
-  // ------------------------------------------------------------------ the end
-  /** The turn is over: its words in the room, its tokens, and the run ended. */
-  async finish(turn, last) {
-    const { run: run2, agent } = turn;
-    if (run2.over) return;
-    await this.closeSteps(turn, "done");
-    for (const approvalId of turn.allowed.splice(0)) {
-      await run2.executed(approvalId, "executed", "Hermes didn't say how it went.").catch(() => void 0);
-    }
-    await this.counted(turn, last);
-    const output2 = typeof last["output"] === "string" ? last["output"].trim() : "";
-    const answer = output2 !== "" ? output2 : turn.reply.trim();
-    const { change, note } = await this.sendProject(turn, answer);
-    const { folder: folder2 } = turn;
-    const { chips: chips2 } = this.options;
-    const words4 = [answer, note ?? ""].filter((part) => part !== "").join("\n\n");
-    const post = await sendAnswer(words4, {
-      folders: folder2 === void 0 ? [] : [folder2],
-      upload: (input2) => chips2.upload(input2)
-    });
-    const reply = post.text;
-    if (reply !== "" || post.uploadIds.length > 0) {
-      await turn.speaker.post({ spaceId: run2.spaceId, runId: run2.id, text: reply, uploadIds: post.uploadIds, change });
+  /** An agent's name, from Chips's list when it isn't known yet. */
+  async nameOf(agentId2, otherwise) {
+    if (!this.names.has(agentId2)) {
+      const listed = await this.options.chips.agents.list().catch(() => []);
+      for (const agent of listed) this.names.set(agent.agentId, agent.name);
     }
-    const said2 = post.summary;
-    const summary = said2 === "" ? "Done." : said2.length <= 2e3 ? said2 : `${said2.slice(0, 1990)}\u2026`;
-    await run2.complete({ summary });
-    this.log(`${agent.config.name} answered in ${run2.spaceId}`);
-    this.missingReadings();
+    return this.names.get(agentId2) ?? otherwise;
+  }
+  /**
+   * The folder an agent works in and sends its files from: the one the config names for them all
+   * (`folder`, as it was), else one of its own under `folders`, named after it the first time it
+   * takes a turn and kept, so a rename keeps it. Every agent once shared one folder, and a team's
+   * files overwrote a one-agent room's game (Chips TT-16); and the one folder had to be Hermes's
+   * own working folder, which a plain Hermes doesn't set (the setup audit, 17 October 2026).
+   */
+  folderOf(agent, agentId2, name2) {
+    if (agent.config.folder !== void 0) return agent.config.folder;
+    const { folders: root2, state: state2 } = this.options;
+    if (root2 === void 0) return void 0;
+    const kept = state2.folders?.[agentId2];
+    const folder2 = kept ?? freeFolder(root2, name2, Object.values(state2.folders ?? {}));
+    mkdirSync5(folder2, { recursive: true });
+    if (kept === void 0) {
+      state2.folders = { ...state2.folders, [agentId2]: folder2 };
+      this.options.saveState(state2);
+    }
+    return folder2;
   }
   /**
-   * A turn ended and Hermes sent no reading at all since the bridge started: its gateway most
-   * likely started before Chips's webhook was in its config. Said once, a little after, since a
-   * reading comes a moment after its model call.
+   * The room's project for a turn (Chips ADR 0221): the agent's copy, in its folder, brought up to
+   * date, and what the turn is told of it. None for an agent a person pointed at a folder of their
+   * own, nor where this machine has no git for it.
    */
-  missingReadings() {
-    if (this.fills === void 0 || this.fillsPort === void 0 || this.fills.anyHeard || this.toldNoReadings) return;
-    this.toldNoReadings = true;
-    setTimeout(() => {
-      if (this.fills?.anyHeard === false) {
-        this.log(
-          "context window: Hermes sent no reading after a turn. Start hermes gateway again once, so it takes Chips's webhook from its config."
-        );
-      }
-    }, 1e4).unref();
-  }
-  /** A run that failed, was stopped or was cut short in Hermes. */
-  async ended(turn, last) {
-    await this.closeSteps(turn, "failed");
-    await this.counted(turn, last);
-    if (turn.cancelled || turn.run.over) return;
-    const name2 = turn.agent.config.name;
-    if (last.event === "run.cancelled") await this.failed(turn, `${name2}'s run was stopped in Hermes.`, false);
-    else if (last.event === "run.interrupted") await this.failed(turn, `Hermes restarted during ${name2}'s run.`, true);
-    else {
-      const why = typeof last["error"] === "string" && last["error"] !== "" ? last["error"] : "it failed in Hermes";
-      await this.failed(turn, `${name2}: ${why}`, true);
+  async projectFor(turn, spaceId, agentId2, name2) {
+    if (this.options.projects !== true || turn.agent.config.folder !== void 0) return void 0;
+    const folder2 = turn.folder;
+    if (folder2 === void 0) return void 0;
+    try {
+      const project = this.options.chips.project({ spaceId, agentId: agentId2, name: name2, folder: folder2, log: (line2) => this.log(line2) });
+      const facts = await project.pull();
+      turn.project = { copy: project, name: name2 };
+      return facts;
+    } catch (error62) {
+      this.log(`${name2}'s copy of the room's project couldn't be readied: ${messageOf3(error62)}`);
+      return void 0;
     }
   }
   /**
-   * The tokens Hermes counted, as a step's share, so they add up over the turn's runs. Hermes's
-   * `input_tokens` is already every token in, its cache's reads and writes among them (its
-   * `CanonicalUsage.prompt_tokens`), which is what Chips counts (Chips ADR 0214); the cache's two
-   * counts go with it, and are left out where Hermes doesn't say them.
+   * What the turn changed in its copy, sent to the room's project before its words are posted: the
+   * commit it left `main` at, for the reply to carry (Chips ADR 0222), when it sent one; else, when
+   * the change didn't go, the line the reply says so in (Chips AP-6).
    */
-  async counted(turn, last) {
-    const usage2 = last["usage"] ?? {};
-    const count = (key) => typeof usage2[key] === "number" ? usage2[key] : void 0;
-    const input2 = count("input_tokens") ?? 0;
-    const output2 = count("output_tokens") ?? 0;
-    if (input2 + output2 === 0) return;
-    const runtime = last["runtime"] ?? {};
-    const model = typeof runtime["model"] === "string" ? runtime["model"] : turn.agent.config.model ?? "hermes";
-    await turn.run.usage({
-      scope: "step",
-      model,
-      inputTokens: input2,
-      cacheReadTokens: count("cache_read_tokens"),
-      cacheWriteTokens: count("cache_write_tokens"),
-      outputTokens: output2
-    }).catch(() => void 0);
-  }
-  async closeSteps(turn, status) {
-    for (const [, ids2] of turn.open) {
-      for (const stepId of ids2) await turn.run.step({ stepId, status }).catch(() => void 0);
+  async sendProject(turn, words4) {
+    if (turn.project === void 0) return {};
+    const { copy, name: name2 } = turn.project;
+    try {
+      const pushed = await copy.push({ words: words4 });
+      this.log(`${name2}'s project: ${pushedInWords(pushed)}`);
+      if (pushed.state === "sent") return { change: pushed.commit };
+      const note = heldNote(pushed, name2);
+      return note === void 0 ? {} : { note };
+    } catch (error62) {
+      this.log(`${name2}'s project couldn't be sent: ${messageOf3(error62)}`);
+      const note = heldNote({ state: "failed", why: messageOf3(error62) }, name2);
+      return note === void 0 ? {} : { note };
     }
-    turn.open.clear();
   }
-  async failed(turn, error62, retryable) {
-    if (!turn.run.over) await turn.run.fail({ error: error62, retryable }).catch(() => void 0);
-    if (retryable) void this.sayHowItIs();
+  /** Trouble while a profile's gateway doesn't answer, and fine once all do (ADR 0083); nothing while a restart runs. */
+  async sayHowItIs() {
+    if (this.held) return;
+    for (const agent of this.agents) agent.up = await agent.client.healthy();
+    if (this.held) return;
+    const down = this.agents.filter((agent) => !agent.up);
+    if (down.length === 0) this.why = void 0;
+    const chips2 = this.options.chips;
+    const said2 = down.length === 0 ? chips2.reportOk() : chips2.reportTrouble(this.why ?? `Hermes isn't answering for ${down.map((agent) => agent.config.name).join(", ")}`);
+    await said2.catch(() => void 0);
   }
-};
-function choiceOf(decision, choices, command = false) {
-  if (!decision.allowed) return "deny";
-  if (command) return "once";
-  if (decision.scope === "always" && choices.includes("always")) return "always";
-  if (decision.scope !== "once" && choices.includes("session")) return "session";
-  return "once";
-}
-function idOf(event) {
-  const id2 = event["request_id"] ?? event["prompt_id"];
-  return typeof id2 === "string" && id2 !== "" ? id2 : void 0;
-}
-function messageOf2(error62) {
-  if (error62 instanceof HermesError) return `${error62.message} (${error62.status})`;
-  return error62 instanceof Error ? error62.message : String(error62);
-}
-function forkName(original) {
-  return `${original.trim().replace(/ · fork( \d+)?$/, "")} \xB7 fork`;
-}
-function goalOf(message, name2) {
-  const first = message.text.split("\n").find((line2) => line2.trim() !== "")?.trim() ?? "";
-  const named = first.toLowerCase().startsWith(`@${name2.toLowerCase()}`);
-  const goal = named ? first.slice(name2.length + 1).trim() : first.replace(/^@\S+\s*/, "");
-  return (goal === "" ? `Answer ${message.from.display_name}` : goal).slice(0, 300);
-}
-var REPLY_SHOWN = 1500;
-var GOAL_SHOWN = 120;
-function lookAgain(who, reply, note) {
-  const said2 = reply?.trim() ?? "";
-  return [
-    `${who} says your reply in this space wasn't right.`,
-    ...said2 === "" ? [] : [`Your reply:
-\xAB${cut(said2, REPLY_SHOWN)}\xBB`],
-    note === void 0 || note === "" ? "They didn't say what. Read your reply again and find what was wrong." : `What wasn't right: \xAB${note}\xBB`,
-    "Look at it again and answer properly in its place. If it is not clear what was wrong, ask them in one short line. Say plainly what you changed."
-  ].join("\n\n");
-}
-function lookingAgain(note) {
-  const first = note?.split("\n").find((line2) => line2.trim() !== "")?.trim();
-  return first === void 0 ? "Looking again at its reply" : cut(`Looking again: ${first}`, GOAL_SHOWN);
-}
-function cut(text, most) {
-  return text.length <= most ? text : `${text.slice(0, most - 1)}\u2026`;
-}
-function resultWords(preview2) {
-  if (typeof preview2 !== "string" || !preview2.trimStart().startsWith("{")) return preview2;
-  let result;
-  try {
-    result = JSON.parse(preview2);
-  } catch {
-    return preview2;
+  // ------------------------------------------------------------------ what is said to it
+  /** A message for some of its agents: each takes a turn in its room, one after another there. */
+  async hear(message, how = {}) {
+    const spaceId = message.space_id;
+    if (spaceId === void 0) return;
+    const harnessId = this.options.chips.harnessId;
+    for (const taker of message.for ?? [harnessId]) {
+      const agent = await this.runnerOf(taker);
+      if (agent === void 0) continue;
+      const room = this.roomOf(agent, taker, spaceId);
+      room.queue.push({ message, speakerId: taker === harnessId ? void 0 : taker, ...how });
+      void this.pump(room);
+    }
   }
-  if (typeof result !== "object" || result === null || !("output" in result)) return preview2;
-  const { output: output2, error: error62 } = result;
-  const said2 = [output2, error62].find((each) => typeof each === "string" && each.trim() !== "");
-  return typeof said2 === "string" ? said2.trim() : "";
-}
-function lastLine(text) {
-  const lines2 = text.split(/(?<=[.!?])\s+|\n+/).map((line2) => line2.trim()).filter((line2) => line2 !== "");
-  return lines2.at(-1) ?? "";
-}
-function lowerFirst(text) {
-  return text.length === 0 ? text : `${text[0]?.toLowerCase() ?? ""}${text.slice(1)}`;
-}
-
-// src/gateway.ts
-import { spawn as spawn2 } from "node:child_process";
-import { createHash as createHash3 } from "node:crypto";
-import { accessSync as accessSync2, appendFileSync as appendFileSync2, closeSync as closeSync2, constants as constants2, existsSync as existsSync8, openSync as openSync2, readFileSync as readFileSync8, readSync, statSync as statSync4 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename4, delimiter as delimiter2, dirname as dirname5, join as join9, resolve as resolve3 } from "node:path";
-var TIMING = {
-  stopMs: 15e3,
-  killMs: 5e3,
-  earlyMs: 1e4,
-  upMs: 9e4,
-  serviceMs: 15e4,
-  pollMs: 500
-};
-var EXPAT = "/opt/homebrew/opt/expat/lib/libexpat.1.dylib";
-var EXPAT_SYMBOL = "_XML_SetAllocTrackerActivationThreshold";
-function gatewaysOf(agents) {
-  return [...new Set(agents.map(({ address }) => address.url.replace(/\/+$/, "")))].map((url2) => ({ url: url2 }));
-}
-function isLocal(url2) {
-  try {
-    return ["127.0.0.1", "localhost", "[::1]", "::1"].includes(new URL(url2).hostname);
-  } catch {
-    return false;
+  /**
+   * "Not right?" on one of its agents' replies (Chips ADR 0200): a person's note on it, or a bare
+   * 👎 from an older phone, is a turn of the agent that said it, in its session in that room and
+   * in line with the room's other turns, to look again and answer in its place. Any other
+   * reaction is the person's own. Once per event, however often it is heard.
+   */
+  async notRight(feedback2) {
+    const { space_id: spaceId, message_id: messageId } = feedback2;
+    const note = feedback2.kind === "correction" ? (feedback2.text ?? "").trim() : void 0;
+    const flagged = note === void 0 ? feedback2.kind === "reaction" && feedback2.reaction === "\u{1F44E}" : note !== "";
+    if (spaceId === void 0 || !messageId || !flagged || this.lookedAt.has(feedback2.id)) return;
+    this.lookedAt.add(feedback2.id);
+    for (const old of this.lookedAt) {
+      if (this.lookedAt.size <= KEPT_FEEDBACK) break;
+      this.lookedAt.delete(old);
+    }
+    const context = await this.options.chips.roomContext(spaceId, { limit: 200 }).catch(() => void 0);
+    const line2 = context?.lines.find((each) => each.message_id === messageId);
+    const message = {
+      type: "message.new",
+      space_id: spaceId,
+      // An id of its own, so nothing of the turn is taken for the reply's.
+      message_id: messageIdOf(feedback2.id),
+      text: lookAgain(feedback2.from.display_name, line2?.text, note),
+      from: feedback2.from,
+      ...line2 === void 0 ? {} : { for: [line2.from.id] }
+    };
+    await this.hear(message, { goal: lookingAgain(note), sayWho: false });
   }
-}
-function portOf(url2) {
-  const parsed = new URL(url2);
-  return Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
-}
-function line(words4) {
-  const one = words4.replace(/\s+/g, " ").trim();
-  return one.length <= 200 ? one : `${one.slice(0, 199)}\u2026`;
-}
-function whyFrom(output2, code) {
-  const lines2 = output2.split("\n").map((each) => each.trim()).filter((each) => each !== "");
-  const why = lines2.findLast((each) => /^[A-Za-z_][\w.]*(Error|Exception)\b/.test(each)) ?? lines2.at(-1);
-  if (why === void 0) return code === null || code === void 0 ? "it was stopped" : `it exited ${code}`;
-  return why.length <= 200 ? why : why.replace(/\/(?:[^\s/(),:'"]+\/)+([^\s/(),:'"]+)/g, "$1");
-}
-function gatewayRunArgs(command) {
-  const words4 = command.trim().split(/\s+/);
-  const at = words4.findIndex((word) => basename4(word) === "hermes");
-  if (at === -1) return void 0;
-  const args = words4.slice(at + 1);
-  const plain = [];
-  for (let next = 0; next < args.length; next += 1) {
-    const word = args[next] ?? "";
-    if (word === "-p" || word === "--profile") next += 1;
-    else if (!word.startsWith("-")) plain.push(word);
+  /**
+   * Which profile answers for a Chips agent, as `profileOf` says. An agent not settled may be one
+   * being made, or a copy, which is waited for, so that its first message is answered on its own
+   * profile, or in the session it was forked.
+   */
+  async runnerOf(taker) {
+    const settled = taker === this.options.chips.harnessId || this.own.has(taker) || this.agents.some((agent) => agent.agentId === taker);
+    if (!settled) await this.making;
+    return this.profileOf(taker);
+  }
+  /**
+   * Which profile answers for a Chips agent: its own, configured or made for it; a copy's
+   * original's; or the first for the harness itself and for any other of the harness's — its
+   * default agent, one made before profiles were — read afresh once when a name is new.
+   */
+  async profileOf(taker) {
+    const own2 = this.agents.find((agent) => agent.agentId === taker) ?? this.own.get(taker);
+    if (own2 !== void 0) return own2;
+    const copied = this.options.state.profiles?.[taker];
+    const original = copied === void 0 ? void 0 : this.byKey(copied);
+    if (original !== void 0) return original;
+    if (taker !== this.options.chips.harnessId && !this.ours.has(taker)) {
+      const listed = await this.options.chips.agents.list().catch(() => []);
+      for (const agent of listed) {
+        this.ours.add(agent.agentId);
+        this.names.set(agent.agentId, agent.name);
+      }
+    }
+    return taker === this.options.chips.harnessId || this.ours.has(taker) ? this.agents[0] : void 0;
   }
-  return plain[0] === "gateway" && plain[1] === "run" ? args : void 0;
-}
-function serviceOf(system, root2, env = {}) {
-  const home2 = resolve3(root2);
-  const native = resolve3(system.home, ".hermes");
-  const suffix = home2 === native ? "" : dirname5(home2) === join9(native, "profiles") ? basename4(home2) : createHash3("sha256").update(home2).digest("hex").slice(0, 8);
-  if (system.platform === "darwin") {
-    const path = join9(system.home, "Library", "LaunchAgents", `ai.hermes.gateway${suffix ? `-${suffix}` : ""}.plist`);
-    return system.exists(path) ? { kind: "launchd", path } : void 0;
+  /**
+   * The session a turn is taken in: the profile's own in the room, for its agent or the harness
+   * itself, and one of its own for any other of the harness's, so two in a room are two.
+   */
+  roomOf(agent, taker, spaceId) {
+    const own2 = taker === agent.agentId || taker === this.options.chips.harnessId;
+    const id2 = `${own2 ? agent.key : taker}|${spaceId}`;
+    let room = this.rooms.get(id2);
+    if (room === void 0) {
+      room = { id: id2, agent, spaceId, queue: [], busy: false };
+      this.rooms.set(id2, room);
+    }
+    return room;
   }
-  if (system.platform === "linux") {
-    const unit = `hermes-gateway${suffix ? `-${suffix}` : ""}.service`;
-    const user = join9(env["XDG_CONFIG_HOME"] || join9(system.home, ".config"), "systemd", "user", unit);
-    if (system.exists(user)) return { kind: "systemd", path: user };
-    const machine = join9("/etc/systemd/system", unit);
-    if (system.exists(machine)) return { kind: "systemd", path: machine, system: true };
+  async pump(room) {
+    if (room.busy) return;
+    const asked = room.queue.shift();
+    if (asked === void 0) return;
+    room.busy = true;
+    try {
+      await this.turn(room, asked);
+    } catch (error62) {
+      this.log(`a turn of ${room.agent.config.name} went wrong: ${messageOf3(error62)}`);
+    } finally {
+      room.busy = false;
+      void this.contexts?.refresh();
+      void this.pump(room);
+    }
   }
-  return void 0;
-}
-function expand(text, env) {
-  let out = "";
-  let at = 0;
-  while (at < text.length) {
-    const char = text[at] ?? "";
-    if (char === "\\" && at + 1 < text.length) {
-      out += text[at + 1];
-      at += 2;
-    } else if (char !== "$") {
-      out += char;
-      at += 1;
-    } else if (text[at + 1] === "{") {
-      let depth = 1;
-      let end2 = at + 2;
-      for (; end2 < text.length; end2 += 1) {
-        if (text[end2] === "{") depth += 1;
-        else if (text[end2] === "}" && --depth === 0) break;
+  async turn(room, { message, speakerId, goal, sayWho }) {
+    const { agent, spaceId } = room;
+    const speaker = speakerId === void 0 ? this.options.chips : this.options.chips.as(speakerId);
+    const run2 = await speaker.runs.start({ spaceId, goal: goal ?? goalOf(message, agent.config.name) });
+    const turn = {
+      run: run2,
+      speaker,
+      agent,
+      who: speakerId ?? agent.agentId,
+      hermesRun: "",
+      reply: "",
+      saidAt: 0,
+      cancelled: false,
+      next: [],
+      open: /* @__PURE__ */ new Map(),
+      counted: 0,
+      approvals: /* @__PURE__ */ new Map(),
+      allowed: [],
+      interrupted: false
+    };
+    run2.on("cancel", () => {
+      turn.cancelled = true;
+      if (turn.hermesRun !== "") void agent.client.stop(turn.hermesRun).catch(() => void 0);
+    });
+    run2.on("steer", (steer) => {
+      const words4 = `${steer.from?.display_name ?? "The person"} adds: ${steer.text}`;
+      void this.steered(turn, words4, steer.mode);
+    });
+    let session;
+    try {
+      session = await this.sessionFor(room);
+    } catch (error62) {
+      await this.failed(turn, `${agent.config.name} couldn't open a session in Hermes: ${messageOf3(error62)}`, true);
+      return;
+    }
+    const name2 = speakerId === void 0 ? agent.config.name : await this.nameOf(speakerId, agent.config.name);
+    turn.folder = this.folderOf(agent, speakerId ?? agent.agentId, name2);
+    const project = await this.projectFor(turn, room.spaceId, speakerId ?? agent.agentId, name2);
+    let text = promptFor(message, { taker: speakerId, sayWho, project });
+    for (let round = 0; text !== void 0 && !turn.cancelled && !run2.over; round += 1) {
+      const last = await this.once(turn, session, text, `${run2.id}:${round}`);
+      if (last === void 0) return;
+      if (last.event === "run.cancelled" && turn.interrupted && turn.next.length > 0) {
+        turn.interrupted = false;
+        text = turn.next.shift();
+        continue;
       }
-      const inner = /^([A-Za-z_][A-Za-z0-9_]*)(?:(:?)-([\s\S]*))?$/.exec(text.slice(at + 2, end2));
-      if (inner !== null) {
-        const value = env[inner[1] ?? ""];
-        const unset = inner[2] === ":" ? value === void 0 || value === "" : value === void 0;
-        out += inner[3] !== void 0 && unset ? expand(inner[3], env) : value ?? "";
+      if (last.event !== "run.completed") {
+        await this.ended(turn, last);
+        return;
       }
-      at = end2 + 1;
-    } else {
-      const name2 = /^[A-Za-z_][A-Za-z0-9_]*/.exec(text.slice(at + 1))?.[0];
-      out += name2 === void 0 ? "$" : env[name2] ?? "";
-      at += 1 + (name2?.length ?? 0);
+      text = turn.next.shift();
+      if (text === void 0) await this.finish(turn, last);
     }
   }
-  return out;
-}
-function wrapperOf(text, env) {
-  for (const each of text.split("\n")) {
-    const found = /^\s*((?:[A-Za-z_][A-Za-z0-9_]*="(?:[^"\\]|\\.)*"\s+)*)exec\s+"([^"]+)"/.exec(each);
-    if (found === null) continue;
-    const vars = {};
-    for (const set2 of (found[1] ?? "").matchAll(/([A-Za-z_][A-Za-z0-9_]*)="((?:[^"\\]|\\.)*)"/g)) {
-      vars[set2[1] ?? ""] = expand(set2[2] ?? "", env);
+  /** One Hermes run of the turn: started, its events heard to the end. The end, or nothing on failure. */
+  async once(turn, session, text, key) {
+    const { agent } = turn;
+    try {
+      turn.hermesRun = await agent.client.startRun({
+        text,
+        sessionId: session,
+        ...this.runModel(turn),
+        key,
+        instructions: instructionsFor(turn.folder, turn.project !== void 0)
+      });
+    } catch (error62) {
+      await this.failed(turn, `${agent.config.name} couldn't start in Hermes: ${messageOf3(error62)}`, true);
+      return void 0;
+    }
+    if (turn.cancelled) await agent.client.stop(turn.hermesRun).catch(() => void 0);
+    try {
+      const last = await agent.client.events(turn.hermesRun, (event) => this.heard(turn, event));
+      return last ?? await this.endOf(turn);
+    } catch (error62) {
+      this.log(`lost ${agent.config.name}'s run ${turn.hermesRun}: ${messageOf3(error62)}`);
+      return await this.endOf(turn);
     }
-    return { entry: expand(found[2] ?? "", env), vars };
-  }
-  return void 0;
-}
-var NO_HERMES = "The hermes command isn't on this machine's PATH, so Hermes's gateway can't be started.";
-var messageOf3 = (error62) => error62 instanceof Error ? error62.message : String(error62);
-function gatewayEnv(env) {
-  return Object.fromEntries(Object.entries(env).filter(([name2]) => !name2.startsWith("CHIPS_")));
-}
-var Gateways = class {
-  constructor(options) {
-    this.options = options;
   }
-  options;
-  timing = TIMING;
-  /** Each gateway restarted, one after another: what went wrong, in a line, or nothing. */
-  async restart() {
-    const troubles = [];
-    for (const gateway of this.options.gateways) {
-      let trouble;
-      try {
-        trouble = await this.restartOne(gateway);
-      } catch (error62) {
-        trouble = `Restart failed: ${messageOf3(error62)}`;
+  /** The end of a run whose stream was lost: its state read until it is over, as a terminal event. */
+  async endOf(turn) {
+    const by = Date.now() + LOST_STREAM_MS;
+    while (Date.now() < by) {
+      const state2 = await turn.agent.client.run(turn.hermesRun).catch(() => void 0);
+      const status = typeof state2?.["status"] === "string" ? state2["status"] : void 0;
+      if (status !== void 0 && TERMINAL.has(`run.${status}`)) {
+        return { ...state2, event: `run.${status}` };
       }
-      if (trouble !== void 0) troubles.push(trouble);
+      await new Promise((resolve7) => setTimeout(resolve7, 1e3));
     }
-    return troubles.length === 0 ? void 0 : line(troubles.join(" "));
+    await this.failed(turn, `${turn.agent.config.name}'s run in Hermes stopped answering.`, true);
+    return void 0;
   }
-  /** Each local gateway that doesn't answer, started: the bridge is starting. */
-  async startIfDown() {
-    const { system, log: log2 } = this.options;
-    for (const gateway of this.options.gateways) {
-      if (!isLocal(gateway.url)) continue;
-      const port = portOf(gateway.url);
+  /** The room's session: the one it had, or a new one Hermes makes for it. */
+  async sessionFor({ id: id2, agent, spaceId }) {
+    const kept = this.options.state.sessions[id2];
+    if (kept !== void 0) return kept;
+    const who = id2.slice(0, id2.lastIndexOf("|"));
+    const made = await agent.client.newSession(`Chips space ${spaceId}${who === agent.key ? "" : ` \xB7 ${who}`}`);
+    this.options.state.sessions[id2] = made;
+    this.options.saveState(this.options.state);
+    return made;
+  }
+  /**
+   * A person's words for a run that is going. A steer is said to the Hermes run, or to the next one
+   * of the turn when Hermes won't take it now. A follow-up waits for this one to end. An
+   * interrupt stops it, and the turn goes on with the words.
+   */
+  async steered(turn, text, mode) {
+    if (mode === "interrupt" && turn.hermesRun !== "") {
+      turn.next.unshift(text);
+      turn.interrupted = true;
+      await turn.agent.client.stop(turn.hermesRun).catch(() => void 0);
+      return;
+    }
+    if (mode === "steer" && turn.hermesRun !== "") {
       try {
-        if (await system.healthy(gateway.url)) continue;
-        let trouble;
-        if (this.serviceFor(gateway) !== void 0) {
-          log2(`Hermes isn't answering on port ${port}: starting its service, hermes gateway start`);
-          trouble = await this.byService(gateway, "start", void 0);
-        } else {
-          const pid = await system.listener(port);
-          if (pid !== void 0) {
-            log2(`Hermes isn't answering on port ${port}, but pid ${pid} listens there: no second gateway started`);
-            continue;
-          }
-          log2(`Hermes isn't answering on port ${port}: starting hermes gateway run`);
-          trouble = await this.start(gateway, ["gateway", "run"], void 0);
-        }
-        if (trouble !== void 0) log2(trouble);
+        await turn.agent.client.steer(turn.hermesRun, text);
+        return;
       } catch (error62) {
-        log2(`Hermes's gateway on port ${port} couldn't be started: ${messageOf3(error62)}`);
+        this.log(`Hermes didn't take a steer mid-run (${messageOf3(error62)}); saying it next`);
       }
     }
+    turn.next.push(text);
+  }
+  // ------------------------------------------------------------------ what Hermes streams
+  async heard(turn, event) {
+    if (turn.run.over) return;
+    switch (event.event) {
+      case "message.delta":
+        turn.reply += typeof event["delta"] === "string" ? event["delta"] : "";
+        return;
+      case "message.interim":
+      case "reasoning.available":
+        this.sayThought(turn, String(event["text"] ?? ""), event.event === "message.interim" ? "writing" : "thinking");
+        return;
+      case "tool.started":
+      case "subagent.start":
+        await this.started(turn, event);
+        return;
+      case "tool.completed":
+      case "subagent.complete":
+        await this.completed(turn, event);
+        return;
+      case "approval.request":
+        void this.ask(turn, event);
+        return;
+      case "approval.responded":
+        await this.settled(turn, event);
+        return;
+      default:
+        return;
+    }
   }
-  /**
-   * The service of Hermes's root, for the Main agent's gateway: a gateway at another address is
-   * another profile's own, which `hermes gateway status` of the root doesn't speak for.
-   */
-  serviceFor(gateway) {
-    if (gateway !== this.options.gateways[0]) return void 0;
-    return serviceOf(this.options.system, this.options.root, this.options.env);
+  sayThought(turn, text, phase) {
+    const now = Date.now();
+    const line2 = lastLine(text);
+    if (line2 === "" || now - turn.saidAt < QUIET_MS) return;
+    turn.saidAt = now;
+    void turn.run.status({ phase, verbPhrase: line2.slice(0, 200) }).catch(() => void 0);
   }
-  async restartOne(gateway) {
-    const { system, log: log2 } = this.options;
-    if (!isLocal(gateway.url)) {
-      return `Hermes's gateway at ${new URL(gateway.url).host} isn't on this machine, so it can't be restarted from here.`;
-    }
-    const port = portOf(gateway.url);
-    const pid = await system.listener(port);
-    if (this.serviceFor(gateway) !== void 0) {
-      log2("restarting Hermes's service: hermes gateway restart");
-      return this.byService(gateway, "restart", pid);
-    }
-    if (pid === void 0) {
-      if (await system.healthy(gateway.url)) return `Can't tell what answers on port ${port}, so nothing was restarted.`;
-      log2(`nothing listens on port ${port}: starting hermes gateway run`);
-      return this.start(gateway, ["gateway", "run"], void 0);
+  async started(turn, event) {
+    const sub = event.event === "subagent.start";
+    const tool = sub ? "delegate_task" : String(event["tool"] ?? "tool");
+    turn.counted += 1;
+    const callId = typeof event["tool_call_id"] === "string" ? event["tool_call_id"] : void 0;
+    const stepId = callId ?? `${tool}-${turn.counted}`;
+    const lane = callId ?? (sub ? "subagent" : `tool:${tool}`);
+    turn.open.set(lane, [...turn.open.get(lane) ?? [], stepId]);
+    const said2 = sub ? event["goal"] : event["preview"];
+    await turn.run.step({
+      stepId,
+      status: "started",
+      title: `${tool}${typeof said2 === "string" && said2 !== "" ? ` \xB7 ${said2}` : ""}`.slice(0, 300),
+      tool,
+      ...KINDS[tool] === void 0 ? {} : { kind: KINDS[tool] }
+    }).catch(() => void 0);
+  }
+  async completed(turn, event) {
+    const sub = event.event === "subagent.complete";
+    const tool = sub ? "delegate_task" : String(event["tool"] ?? "tool");
+    const callId = typeof event["tool_call_id"] === "string" ? event["tool_call_id"] : void 0;
+    const lane = callId ?? (sub ? "subagent" : `tool:${tool}`);
+    const waiting = turn.open.get(lane) ?? [];
+    const stepId = callId ?? waiting.shift() ?? `${tool}-${turn.counted += 1}`;
+    turn.open.set(lane, waiting.filter((each) => each !== stepId));
+    const failed = event["error"] === true || sub && event["status"] === "failed";
+    const approvalId = sub ? void 0 : turn.allowed.shift();
+    if (approvalId !== void 0) {
+      await turn.run.executed(approvalId, failed ? "failed" : "executed").catch(() => void 0);
     }
-    const info = await system.describe(pid);
-    if (info === void 0) return this.start(gateway, ["gateway", "run"], void 0);
-    const args = this.ours(info);
-    if (args === void 0) {
-      log2(`pid ${pid} on port ${port} isn't this user's hermes gateway run, so it was left alone: ${info.command.slice(0, 160)}`);
-      return `Port ${port} is held by something other than hermes gateway run (pid ${pid}), so nothing was restarted.`;
+    const summary = sub ? event["summary"] : resultWords(event["preview"]);
+    const seconds = typeof event["duration"] === "number" ? event["duration"] : void 0;
+    await turn.run.step({
+      stepId,
+      status: failed ? "failed" : "done",
+      tool,
+      ...typeof summary === "string" && summary !== "" ? { summary: summary.slice(0, 2e3) } : {},
+      ...seconds === void 0 ? {} : { durationMs: Math.round(seconds * 1e3) }
+    }).catch(() => void 0);
+    const cost3 = event["cost_usd"];
+    if (sub && typeof cost3 === "number" && cost3 > 0) {
+      const model = typeof event["model"] === "string" ? event["model"] : "subagent";
+      await turn.run.usage({ scope: "step", model, costUsd: cost3 }).catch(() => void 0);
     }
-    if (system.which("hermes", this.options.env) === void 0) return NO_HERMES;
-    log2(`stopping Hermes's gateway, pid ${pid}`);
-    if (!await this.stop(pid)) return `Hermes's gateway (pid ${pid}) didn't stop, so it wasn't started again.`;
-    return this.start(gateway, args, info.cwd);
   }
-  /** A `hermes gateway run` of this user's: the words to start it again with. */
-  ours(info) {
-    return info.uid === this.options.system.uid ? gatewayRunArgs(info.command) : void 0;
+  // ------------------------------------------------------------------ what Hermes asks
+  /** An approval Hermes wants before it acts, as a card; the answer is Hermes's choice. */
+  async ask(turn, event) {
+    const requestId = idOf(event);
+    const command = typeof event["command"] === "string" ? event["command"] : void 0;
+    const description = typeof event["description"] === "string" ? event["description"] : void 0;
+    const choices = Array.isArray(event["choices"]) ? event["choices"].map(String) : ["once", "deny"];
+    const approvalId = ids.next("approval");
+    turn.approvals.set(requestId ?? approvalId, { approvalId, answered: false });
+    const asked = turn.run.approval({
+      approvalId,
+      action: {
+        kind: command === void 0 ? "hermes.approval" : "shell.exec",
+        input: { ...command === void 0 ? {} : { command }, ...description === void 0 ? {} : { description } }
+      },
+      question: (description === void 0 ? "Run this command?" : `Allow it to ${lowerFirst(description)}?`).slice(0, 300),
+      lasts: "once",
+      risk: [],
+      ...command === void 0 ? {} : { preview: { format: "markdown", title: "Run a command", body: `\`\`\`sh
+${command}
+\`\`\`` } }
+    });
+    const stopped2 = new Promise((resolve7) => turn.run.on("cancel", () => resolve7(void 0)));
+    const decision = await Promise.race([asked, stopped2]);
+    const pending = turn.approvals.get(requestId ?? approvalId);
+    if (decision === void 0 || pending === void 0 || pending.answered) return;
+    pending.answered = true;
+    if (decision.allowed) turn.allowed.push(approvalId);
+    const generation = event["execution_generation"];
+    await turn.agent.client.approve(turn.hermesRun, {
+      choice: choiceOf(decision, choices, command !== void 0),
+      ...requestId === void 0 ? {} : { request_id: requestId },
+      ...typeof generation === "number" ? { execution_generation: generation } : {}
+    }).catch((error62) => this.log(`Hermes didn't take the answer: ${messageOf3(error62)}`));
   }
-  /** SIGTERM, then SIGKILL once it has had a while, and only while it is still that gateway. */
-  async stop(pid) {
-    const { system, log: log2 } = this.options;
-    system.signal(pid, "SIGTERM");
-    if (await this.gone(pid, this.timing.stopMs)) return true;
-    const still = await system.describe(pid);
-    if (still === void 0) return true;
-    if (this.ours(still) === void 0) return false;
-    log2(`Hermes's gateway, pid ${pid}, is still running ${this.timing.stopMs / 1e3} s after SIGTERM: SIGKILL`);
-    system.signal(pid, "SIGKILL");
-    return this.gone(pid, this.timing.killMs);
+  /** An approval answered in Hermes's own tools: settled in Chips, once, so the card cools (ADR 0079). */
+  async settled(turn, event) {
+    const requestId = idOf(event);
+    const pending = requestId === void 0 ? void 0 : turn.approvals.get(requestId);
+    if (pending === void 0 || pending.answered) return;
+    pending.answered = true;
+    const denied = event["choice"] === "deny";
+    await this.options.chips.send(
+      "approval.resolved",
+      { run_id: turn.run.id },
+      {
+        approval_id: pending.approvalId,
+        decision: denied ? "denied" : "approved",
+        scope: "once",
+        reason: "Answered in Hermes."
+      },
+      `hermes-approval:${turn.hermesRun}:${requestId}:settled`
+    ).catch(() => void 0);
   }
-  async gone(pid, withinMs) {
-    const { system } = this.options;
-    const by = system.now() + withinMs;
-    while (system.alive(pid)) {
-      if (system.now() >= by) return false;
-      await system.sleep(this.timing.pollMs);
+  // ------------------------------------------------------------------ the end
+  /** The turn is over: its words in the room, its tokens, and the run ended. */
+  async finish(turn, last) {
+    const { run: run2, agent } = turn;
+    if (run2.over) return;
+    await this.closeSteps(turn, "done");
+    for (const approvalId of turn.allowed.splice(0)) {
+      await run2.executed(approvalId, "executed", "Hermes didn't say how it went.").catch(() => void 0);
     }
-    return true;
-  }
-  /** Hermes's own `hermes gateway restart|start`, then the gateway answering, from a new process. */
-  async byService(gateway, verb, before) {
-    const { system, env } = this.options;
-    const hermes = system.which("hermes", env);
-    if (hermes === void 0) return NO_HERMES;
-    const scope = this.serviceFor(gateway)?.system === true ? ["--system"] : [];
-    const ran = await system.run(hermes, ["gateway", verb, ...scope], gatewayEnv(env), this.timing.serviceMs);
-    if (ran.code !== 0) return line(`hermes gateway ${verb} failed: ${whyFrom(ran.output, ran.code)}`);
-    const by = system.now() + this.timing.serviceMs;
-    for (; ; ) {
-      const old = before !== void 0 && system.alive(before);
-      if (!old && await system.healthy(gateway.url)) return void 0;
-      if (system.now() >= by) {
-        if (await system.healthy(gateway.url)) return void 0;
-        return `Hermes's service ${verb === "start" ? "started" : "restarted"}, but nothing answers on port ${portOf(gateway.url)}.`;
-      }
-      await system.sleep(this.timing.pollMs);
+    await this.counted(turn, last);
+    const output2 = typeof last["output"] === "string" ? last["output"].trim() : "";
+    const answer = output2 !== "" ? output2 : turn.reply.trim();
+    const { change, note } = await this.sendProject(turn, answer);
+    const { folder: folder2 } = turn;
+    const { chips: chips2 } = this.options;
+    const words4 = [answer, note ?? ""].filter((part) => part !== "").join("\n\n");
+    const post = await sendAnswer(words4, {
+      folders: folder2 === void 0 ? [] : [folder2],
+      upload: (input2) => chips2.upload(input2)
+    });
+    const reply = post.text;
+    if (reply !== "" || post.uploadIds.length > 0) {
+      await turn.speaker.post({ spaceId: run2.spaceId, runId: run2.id, text: reply, uploadIds: post.uploadIds, change });
     }
+    const said2 = post.summary;
+    const summary = said2 === "" ? "Done." : said2.length <= 2e3 ? said2 : `${said2.slice(0, 1990)}\u2026`;
+    await run2.complete({ summary });
+    this.log(`${agent.config.name} answered in ${run2.spaceId}`);
+    this.missingReadings();
   }
   /**
-   * `hermes <args>` (`gateway run`), on its own, in `cwd` (else the home), then through Homebrew's
-   * expat when it died of macOS's.
+   * A turn ended and Hermes sent no reading at all since the bridge started: its gateway most
+   * likely started before Chips's webhook was in its config. Said once, a little after, since a
+   * reading comes a moment after its model call.
    */
-  async start(gateway, args, cwd) {
-    const { system, env, log: log2 } = this.options;
-    const port = portOf(gateway.url);
-    const hermes = system.which("hermes", env);
-    if (hermes === void 0) return NO_HERMES;
-    const folder2 = cwd ?? system.home;
-    const plain = gatewayEnv(env);
-    let outcome = await this.launch(gateway, hermes, args, plain, folder2, `hermes ${args.join(" ")}`);
-    if (outcome.state === "ended" && outcome.early && outcome.output.includes(EXPAT_SYMBOL) && system.exists(EXPAT)) {
-      const wrapper = wrapperOf(system.read(hermes) ?? "", plain);
-      if (wrapper !== void 0) {
-        const expat = dirname5(EXPAT);
-        log2(
-          `hermes gateway run stopped at once: Homebrew's Python can't load macOS's expat (${EXPAT_SYMBOL}). Starting ${wrapper.entry} directly with DYLD_LIBRARY_PATH=${expat}.`
-        );
-        const libraries = [expat, plain["DYLD_LIBRARY_PATH"]].filter((each) => each !== void 0 && each !== "").join(":");
-        outcome = await this.launch(
-          gateway,
-          wrapper.entry,
-          args,
-          { ...plain, ...wrapper.vars, DYLD_LIBRARY_PATH: libraries },
-          folder2,
-          `${wrapper.entry} ${args.join(" ")} with DYLD_LIBRARY_PATH=${expat}`
-        );
-      }
-    }
-    if (outcome.state === "up") {
-      log2(`Hermes's gateway${outcome.pid === void 0 ? "" : `, pid ${outcome.pid},`} answers on port ${port}. It logs to ${this.options.logFile}.`);
-      return void 0;
-    }
-    if (outcome.state === "silent") return `Hermes's gateway started, but nothing answers on port ${port}.`;
-    return line(`Hermes's gateway stopped as it started: ${whyFrom(outcome.output, outcome.code)}`);
-  }
-  /** A program started, and watched until it answers, ends, or has had its time. */
-  async launch(gateway, command, args, env, cwd, what) {
-    const { system, logFile } = this.options;
-    system.note(logFile, `--- ${new Date(system.now()).toISOString()} chips-hermes started ${what}`);
-    const from = system.size(logFile);
-    const startedAt = system.now();
-    const child = system.launch({ command, args, env, cwd, log: logFile });
-    let ended;
-    void child.exited.then(({ code }) => {
-      ended = { code, at: system.now() };
-    });
-    for (; ; ) {
-      await Promise.resolve();
-      if (ended !== void 0) {
-        return { state: "ended", early: ended.at - startedAt <= this.timing.earlyMs, output: system.since(logFile, from), code: ended.code };
+  missingReadings() {
+    if (this.fills === void 0 || this.fillsPort === void 0 || this.fills.anyHeard || this.toldNoReadings) return;
+    this.toldNoReadings = true;
+    setTimeout(() => {
+      if (this.fills?.anyHeard === false) {
+        this.log(
+          "context window: Hermes sent no reading after a turn. Start hermes gateway again once, so it takes Chips's webhook from its config."
+        );
       }
-      if (await system.healthy(gateway.url)) return { state: "up", pid: child.pid };
-      if (system.now() - startedAt >= this.timing.upMs) return { state: "silent" };
-      await system.sleep(this.timing.pollMs);
+    }, 1e4).unref();
+  }
+  /** A run that failed, was stopped or was cut short in Hermes. */
+  async ended(turn, last) {
+    await this.closeSteps(turn, "failed");
+    await this.counted(turn, last);
+    if (turn.cancelled || turn.run.over) return;
+    const name2 = turn.agent.config.name;
+    if (last.event === "run.cancelled") await this.failed(turn, `${name2}'s run was stopped in Hermes.`, false);
+    else if (last.event === "run.interrupted") await this.failed(turn, `Hermes restarted during ${name2}'s run.`, true);
+    else {
+      const why = typeof last["error"] === "string" && last["error"] !== "" ? last["error"] : "it failed in Hermes";
+      await this.failed(turn, `${name2}: ${why}`, true);
     }
   }
-};
-function restarter(deps) {
-  let running;
-  return (ask2) => {
-    if (running !== void 0) {
-      deps.log(`restart asked by ${ask2.askedBy} while one runs: it is the same restart`);
-      return running;
+  /**
+   * The tokens Hermes counted, as a step's share, so they add up over the turn's runs. Hermes's
+   * `input_tokens` is already every token in, its cache's reads and writes among them (its
+   * `CanonicalUsage.prompt_tokens`), which is what Chips counts (Chips ADR 0214); the cache's two
+   * counts go with it, and are left out where Hermes doesn't say them.
+   */
+  async counted(turn, last) {
+    const usage2 = last["usage"] ?? {};
+    const count = (key) => typeof usage2[key] === "number" ? usage2[key] : void 0;
+    const input2 = count("input_tokens") ?? 0;
+    const output2 = count("output_tokens") ?? 0;
+    if (input2 + output2 === 0) return;
+    const runtime = last["runtime"] ?? {};
+    const model = typeof runtime["model"] === "string" ? runtime["model"] : this.runModel(turn).model ?? "hermes";
+    await turn.run.usage({
+      scope: "step",
+      model,
+      inputTokens: input2,
+      cacheReadTokens: count("cache_read_tokens"),
+      cacheWriteTokens: count("cache_write_tokens"),
+      outputTokens: output2
+    }).catch(() => void 0);
+  }
+  async closeSteps(turn, status) {
+    for (const [, ids2] of turn.open) {
+      for (const stepId of ids2) await turn.run.step({ stepId, status }).catch(() => void 0);
     }
-    running = (async () => {
-      deps.log(`restart asked by ${ask2.askedBy}: restarting Hermes's gateway`);
-      deps.hold(true);
-      let trouble;
-      try {
-        trouble = await deps.restart();
-      } catch (error62) {
-        trouble = line(`Restart failed: ${error62 instanceof Error ? error62.message : String(error62)}`);
-      }
-      deps.log(trouble === void 0 ? "restarted, and Hermes answers" : `restart: ${trouble}`);
-      try {
-        await deps.say(trouble);
-      } catch (error62) {
-        deps.log(`could not tell Chips how the restart went: ${String(error62)}`);
-      } finally {
-        deps.hold(false);
-      }
-    })().finally(() => {
-      running = void 0;
-    });
-    return running;
-  };
+    turn.open.clear();
+  }
+  async failed(turn, error62, retryable) {
+    if (!turn.run.over) await turn.run.fail({ error: error62, retryable }).catch(() => void 0);
+    if (retryable) void this.sayHowItIs();
+  }
+};
+function choiceOf(decision, choices, command = false) {
+  if (!decision.allowed) return "deny";
+  if (command) return "once";
+  if (decision.scope === "always" && choices.includes("always")) return "always";
+  if (decision.scope !== "once" && choices.includes("session")) return "session";
+  return "once";
 }
-function gatewayLog(configFolder, platform = process.platform) {
-  return platform === "darwin" ? join9(homedir5(), "Library", "Logs", "chips-hermes-gateway.log") : join9(configFolder, "gateway.log");
+function idOf(event) {
+  const id2 = event["request_id"] ?? event["prompt_id"];
+  return typeof id2 === "string" && id2 !== "" ? id2 : void 0;
 }
-function runToEnd(command, args, options) {
-  return new Promise((done) => {
-    const child = spawn2(command, args, { env: options.env, stdio: ["ignore", "pipe", "pipe"] });
-    let output2 = "";
-    const keep = (data) => {
-      output2 = (output2 + String(data)).slice(-8e3);
-    };
-    child.stdout.on("data", keep);
-    child.stderr.on("data", keep);
-    const limit = setTimeout(() => child.kill("SIGTERM"), options.timeoutMs);
-    child.on("error", (error62) => {
-      clearTimeout(limit);
-      done({ code: null, output: error62.message });
-    });
-    child.on("close", (code) => {
-      clearTimeout(limit);
-      done({ code, output: output2 });
-    });
-  });
+function messageOf3(error62) {
+  if (error62 instanceof HermesError) return `${error62.message} (${error62.status})`;
+  return error62 instanceof Error ? error62.message : String(error62);
 }
-function thisMachine() {
-  return {
-    platform: process.platform,
-    uid: process.getuid?.() ?? -1,
-    home: homedir5(),
-    exists: existsSync8,
-    read(path) {
-      try {
-        return readFileSync8(path, "utf8");
-      } catch {
-        return void 0;
-      }
-    },
-    which(command, env) {
-      for (const folder2 of (env["PATH"] ?? "").split(delimiter2)) {
-        if (folder2 === "") continue;
-        const path = join9(folder2, command);
-        try {
-          accessSync2(path, constants2.X_OK);
-          return path;
-        } catch {
-        }
-      }
-      return void 0;
-    },
-    async listener(port) {
-      const { output: output2 } = await runToEnd("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-Fp"], { timeoutMs: 5e3 });
-      const pid = Number(/^p(\d+)$/m.exec(output2)?.[1]);
-      return Number.isInteger(pid) && pid > 0 ? pid : void 0;
-    },
-    async describe(pid) {
-      const { code, output: output2 } = await runToEnd("ps", ["-ww", "-o", "uid=", "-o", "command=", "-p", String(pid)], { timeoutMs: 5e3 });
-      const found = /^\s*(\d+)\s+(.*)$/m.exec(output2);
-      if (code !== 0 || found === null) return void 0;
-      return { uid: Number(found[1]), command: found[2] ?? "", cwd: processFolder(pid) };
-    },
-    alive(pid) {
-      try {
-        process.kill(pid, 0);
-        return true;
-      } catch (error62) {
-        return error62.code === "EPERM";
-      }
-    },
-    signal(pid, signal) {
-      try {
-        process.kill(pid, signal);
-      } catch {
-      }
-    },
-    run: (command, args, env, timeoutMs) => runToEnd(command, args, { env, timeoutMs }),
-    launch({ command, args, env, cwd, log: log2 }) {
-      const out = openSync2(log2, "a");
-      try {
-        const child = spawn2(command, args, { cwd, env, detached: true, stdio: ["ignore", out, out] });
-        const exited = new Promise((done) => {
-          child.once("exit", (code, signal) => done({ code, signal }));
-          child.once("error", (error62) => {
-            appendFileSync2(log2, `${error62.message}
-`);
-            done({ code: null, signal: null });
-          });
-        });
-        child.unref();
-        return { pid: child.pid, exited };
-      } finally {
-        closeSync2(out);
-      }
-    },
-    note(log2, words4) {
-      appendFileSync2(log2, `${words4}
-`);
-    },
-    size(log2) {
-      try {
-        return statSync4(log2).size;
-      } catch {
-        return 0;
-      }
-    },
-    since(log2, from) {
-      try {
-        const to = statSync4(log2).size;
-        const start = Math.max(from, to - 64e3);
-        const buffer = Buffer.alloc(Math.max(0, to - start));
-        const fd = openSync2(log2, "r");
-        try {
-          readSync(fd, buffer, 0, buffer.length, start);
-        } finally {
-          closeSync2(fd);
-        }
-        return buffer.toString("utf8");
-      } catch {
-        return "";
-      }
-    },
-    healthy: (url2) => new HermesClient({ url: url2, key: "" }, (input2, init) => fetch(input2, { ...init, signal: AbortSignal.timeout(5e3) })).healthy(),
-    sleep: (ms) => new Promise((done) => setTimeout(done, ms)),
-    now: () => Date.now()
-  };
+function titleFrom(text) {
+  const line2 = text.trim().split("\n")[0] ?? "";
+  if (line2.length <= 48) return line2;
+  const cut2 = line2.slice(0, 48);
+  return `${cut2.slice(0, Math.max(cut2.lastIndexOf(" "), 24))}\u2026`;
+}
+function forkName(original) {
+  return `${original.trim().replace(/ · fork( \d+)?$/, "")} \xB7 fork`;
+}
+function goalOf(message, name2) {
+  const first = message.text.split("\n").find((line2) => line2.trim() !== "")?.trim() ?? "";
+  const named = first.toLowerCase().startsWith(`@${name2.toLowerCase()}`);
+  const goal = named ? first.slice(name2.length + 1).trim() : first.replace(/^@\S+\s*/, "");
+  return (goal === "" ? `Answer ${message.from.display_name}` : goal).slice(0, 300);
+}
+var REPLY_SHOWN = 1500;
+var GOAL_SHOWN = 120;
+function lookAgain(who, reply, note) {
+  const said2 = reply?.trim() ?? "";
+  return [
+    `${who} says your reply in this space wasn't right.`,
+    ...said2 === "" ? [] : [`Your reply:
+\xAB${cut(said2, REPLY_SHOWN)}\xBB`],
+    note === void 0 || note === "" ? "They didn't say what. Read your reply again and find what was wrong." : `What wasn't right: \xAB${note}\xBB`,
+    "Look at it again and answer properly in its place. If it is not clear what was wrong, ask them in one short line. Say plainly what you changed."
+  ].join("\n\n");
+}
+function lookingAgain(note) {
+  const first = note?.split("\n").find((line2) => line2.trim() !== "")?.trim();
+  return first === void 0 ? "Looking again at its reply" : cut(`Looking again: ${first}`, GOAL_SHOWN);
+}
+function cut(text, most) {
+  return text.length <= most ? text : `${text.slice(0, most - 1)}\u2026`;
+}
+function resultWords(preview2) {
+  if (typeof preview2 !== "string" || !preview2.trimStart().startsWith("{")) return preview2;
+  let result;
+  try {
+    result = JSON.parse(preview2);
+  } catch {
+    return preview2;
+  }
+  if (typeof result !== "object" || result === null || !("output" in result)) return preview2;
+  const { output: output2, error: error62 } = result;
+  const said2 = [output2, error62].find((each) => typeof each === "string" && each.trim() !== "");
+  return typeof said2 === "string" ? said2.trim() : "";
+}
+function lastLine(text) {
+  const lines2 = text.split(/(?<=[.!?])\s+|\n+/).map((line2) => line2.trim()).filter((line2) => line2 !== "");
+  return lines2.at(-1) ?? "";
+}
+function lowerFirst(text) {
+  return text.length === 0 ? text : `${text[0]?.toLowerCase() ?? ""}${text.slice(1)}`;
 }
 
 // src/keep.ts
 import { homedir as homedir6 } from "node:os";
-import { basename as basename5, join as join10, resolve as resolve4 } from "node:path";
+import { basename as basename5, join as join11, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var flags = process.argv.slice(2);
 var words3 = flags.filter((word) => !word.startsWith("--"));
-var whole = (word) => resolve4(word.startsWith("~/") ? join10(homedir6(), word.slice(2)) : word);
+var whole = (word) => resolve4(word.startsWith("~/") ? join11(homedir6(), word.slice(2)) : word);
 var here = fileURLToPath2(new URL("..", import.meta.url)).replace(/\/$/, "");
 var self = fileURLToPath2(import.meta.url);
 var run = self.endsWith(".js") ? [self] : ["--import", "tsx", "src/main.ts"];
@@ -28117,9 +28528,9 @@ function keepIfAsked(label2, url2, names, log2, before = () => void 0) {
 }
 
 // src/setup.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join11, resolve as resolve5 } from "node:path";
+import { join as join12, resolve as resolve5 } from "node:path";
 var SetupError = class extends Error {
   constructor(message, words4 = {}) {
     super(message);
@@ -28144,16 +28555,16 @@ function readyHooks(config3, options) {
   const lines2 = [];
   let restart2 = false;
   const done = /* @__PURE__ */ new Set();
-  for (const agent of config3.agents) {
-    const profile = profileName(agent.address.profile);
+  for (const named of [...config3.agents.map((agent) => agent.address.profile), ...options.made ?? []]) {
+    const profile = profileName(named);
     if (done.has(profile)) continue;
     done.add(profile);
-    const home2 = profileHome(options.root, agent.address.profile);
+    const home2 = profileHome(options.root, named);
     let outcome;
     try {
       outcome = addHook(home2, options.port, profile, options.secret);
     } catch (error62) {
-      lines2.push(`Chips's webhook wasn't added to ${shown(join11(home2, "config.yaml"))}: ${error62 instanceof Error ? error62.message : String(error62)}`);
+      lines2.push(`Chips's webhook wasn't added to ${shown(join12(home2, "config.yaml"))}: ${error62 instanceof Error ? error62.message : String(error62)}`);
       continue;
     }
     if (outcome.state === "added") {
@@ -28179,8 +28590,8 @@ function hermesEnvPath(env = process.env) {
 }
 function fromHermes(name2, env) {
   const path = hermesEnvPath(env);
-  if (!existsSync9(path)) return void 0;
-  for (const line2 of readFileSync9(path, "utf8").split("\n")) {
+  if (!existsSync10(path)) return void 0;
+  for (const line2 of readFileSync10(path, "utf8").split("\n")) {
     const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line2);
     if (match?.[1] === name2) return match[2]?.replace(/^(["'])(.*)\1$/, "$2");
   }
@@ -28191,7 +28602,7 @@ function folderOf(said2) {
   return resolve5(said2 === "~" || said2.startsWith("~/") ? homedir7() + said2.slice(1) : said2);
 }
 function readConfig(path, env = process.env) {
-  const raw = existsSync9(path) ? JSON.parse(readFileSync9(path, "utf8")) : PLAIN;
+  const raw = existsSync10(path) ? JSON.parse(readFileSync10(path, "utf8")) : PLAIN;
   const url2 = typeof raw.url === "string" ? raw.url : "http://127.0.0.1:8642";
   const folder2 = folderOf(raw.folder);
   if (!Array.isArray(raw.agents) || raw.agents.length === 0) {
@@ -28262,14 +28673,14 @@ async function checkHermes(config3, clientFor = (agent) => new HermesClient(agen
 }
 
 // src/main.ts
-var home = (path) => path.startsWith("~/") ? join12(homedir8(), path.slice(2)) : path;
+var home = (path) => path.startsWith("~/") ? join13(homedir8(), path.slice(2)) : path;
 var link = process.env["CHIPS_JOIN_LINK"] || void 0;
 var LABEL = "chat.chips.hermes";
 stopIfAsked(LABEL);
 var configPath = resolve6(home(words3[0] ?? "~/.chips-hermes/config.json"));
 var folder = dirname6(configPath);
-var statePath = join12(folder, "sessions.json");
-var state = existsSync10(statePath) ? JSON.parse(readFileSync10(statePath, "utf8")) : { sessions: {} };
+var statePath = join13(folder, "sessions.json");
+var state = existsSync11(statePath) ? JSON.parse(readFileSync11(statePath, "utf8")) : { sessions: {} };
 var saveState = (next) => {
   mkdirSync6(folder, { recursive: true, mode: 448 });
   writeFileSync5(statePath, `${JSON.stringify(next, null, 2)}
@@ -28294,12 +28705,13 @@ try {
     reportStep("checking", { detail: "Looking for its API server" });
     await checkHermes(config2);
   }
-  fills.secret ??= randomBytes2(32).toString("hex");
+  fills.secret ??= randomBytes3(32).toString("hex");
   fills.port = config2.hookPort ?? fills.port ?? hookPortIn(profileHome(root, config2.agents[0]?.address.profile)) ?? await freePort();
   saveState(state);
   const first = config2.agents[0];
   const gatewayUp = link !== void 0 || first !== void 0 && await new HermesClient(first.address).healthy();
-  const hooks = readyHooks(config2, { root, port: fills.port, secret: fills.secret, gatewayUp });
+  const made = Object.values(state.made ?? {});
+  const hooks = readyHooks(config2, { root, port: fills.port, secret: fills.secret, gatewayUp, made });
   for (const line2 of hooks.lines) log(line2);
   if (link !== void 0) reportStep("checked", { detail: checkedWords(config2, hooks.restart) });
 } catch (error62) {
@@ -28348,7 +28760,7 @@ var chips = await connect({
   url: joined.url,
   token: joined.token,
   client: { name: "chips-hermes", version: "1.0.0" },
-  store: fileStore(join12(folder, "chips-state.json")),
+  store: fileStore(join13(folder, "chips-state.json")),
   onRestart: restart,
   settings: settingsFor(() => bridge)
 });
@@ -28364,7 +28776,10 @@ bridge = new Bridge({
   saveState,
   log,
   hermesRoot: root,
-  fills: { port: fills.port, secret: fills.secret }
+  fills: { port: fills.port, secret: fills.secret },
+  // Each agent made in Chips is a Hermes profile of its own (Chips ADR 0241).
+  profiles: hermesProfiles({ root, env: process.env, system: thisMachine(), log: (line2) => log(`profiles: ${line2}`) }),
+  restartGateway: () => restart({ askedBy: "chips-hermes, for a new agent's profile", askedAt: (/* @__PURE__ */ new Date()).toISOString() })
 });
 await bridge.start();
 log(`answering for ${config2.agents.map((agent) => agent.name).join(", ")} through Hermes`);