@chipschat/opencode 1.0.4 → 1.0.7

package/dist/main.js

@@ -8,9 +8,9 @@ var __export = (target, all) => {
 };
 
 // src/main.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { dirname as dirname4, join as join9, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname5, join as join10, resolve as resolve4 } from "node:path";
 
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -4871,10 +4871,10 @@ function partPattern(schema) {
   const own2 = schema._zod.pattern?.source;
   const inner = def.innerType ?? schema._zod.innerType;
   if (inner) {
-    const before = inner._zod.pattern?.source;
+    const before2 = inner._zod.pattern?.source;
     const after = partPattern(inner);
-    if (own2 && before && after && after !== before) {
-      return own2.replace(cleanRegex(before), () => cleanRegex(after));
+    if (own2 && before2 && after && after !== before2) {
+      return own2.replace(cleanRegex(before2), () => cleanRegex(after));
     }
     return own2;
   }
@@ -25467,7 +25467,270 @@ function fileStore(path) {
 
 // src/bridge.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join5 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+
+// src/context.ts
+import { createHash as createHash2 } from "node:crypto";
+import { globSync, readFileSync as readFileSync5, statSync } from "node:fs";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join5, relative, sep as sep2 } from "node:path";
+var AGENTS_MD = "AGENTS.md";
+function placesOf(env, home3) {
+  const config3 = env["OPENCODE_CONFIG_DIR"] || join5(env["XDG_CONFIG_HOME"] || join5(home3, ".config"), "opencode");
+  return { home: home3, config: config3 };
+}
+function hashOf(text2) {
+  return createHash2("sha256").update(text2, "utf8").digest("hex");
+}
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function textOf(path) {
+  try {
+    return readFileSync5(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var within = (path, dir) => path === dir || path.startsWith(`${dir}${sep2}`);
+function upTo(dir, stop2) {
+  const dirs = [dir];
+  for (let at = dir; within(at, stop2) && at !== stop2 && dirname4(at) !== at; ) {
+    at = dirname4(at);
+    dirs.push(at);
+  }
+  return dirs;
+}
+function namedFiles(sources, folder2, root, home3) {
+  const found = [];
+  const glob = (pattern, cwd) => {
+    try {
+      return globSync(pattern, { cwd }).map((match) => join5(cwd, match));
+    } catch {
+      return [];
+    }
+  };
+  for (const source2 of sources) {
+    if (/^https?:\/\//i.test(source2)) continue;
+    const expanded = source2.startsWith("~/") ? join5(home3, source2.slice(2)) : source2;
+    const matches = isAbsolute2(expanded) ? glob(expanded.slice(dirname4(expanded).length + 1), dirname4(expanded)) : upTo(folder2, within(folder2, root) ? root : folder2).flatMap((dir) => glob(expanded, dir));
+    for (const path of matches.sort()) if (isFile(path) && !found.includes(path)) found.push(path);
+  }
+  return found;
+}
+function before(version3, than) {
+  const parts = (each) => each.split(/[.-]/).slice(0, 3).map((part) => Number.parseInt(part, 10) || 0);
+  const [a, b] = [parts(version3), parts(than)];
+  for (let at = 0; at < 3; at += 1) if ((a[at] ?? 0) !== (b[at] ?? 0)) return (a[at] ?? 0) < (b[at] ?? 0);
+  return false;
+}
+var READS_NAMED = "2.0.30";
+var ContextFiles = class {
+  constructor(places, folders) {
+    this.places = places;
+    this.folders = folders;
+  }
+  places;
+  folders;
+  /** `~/chips-opencode/agents/AGENTS.md`, or the whole path where it isn't in the home. */
+  tilde(path) {
+    const { home: home3 } = this.places;
+    return within(path, home3) ? `~${path.slice(home3.length)}` : path;
+  }
+  /** A shared file's name: where it is, a step at a time (`~ › .config › opencode › AGENTS.md`), with no slash. */
+  crumbs(path) {
+    const { home: home3 } = this.places;
+    const steps = within(path, home3) ? ["~", ...relative(home3, path).split(sep2)] : ["/", ...path.split(sep2)];
+    return steps.filter((step) => step !== "").join(" \u203A ").slice(0, 255);
+  }
+  /**
+   * The harness's own set, for agents whose folders read as `readings` says: every agent's
+   * `AGENTS.md`, those above it, the person's own, and the named files not in an agent's folder.
+   */
+  sharedSpots(readings) {
+    const { places, folders } = this;
+    const spots = [];
+    const add = (spot) => {
+      if (!spots.some((each) => each.path === spot.path)) spots.push(spot);
+    };
+    const reaches = (dir) => (folder2) => within(folder2, dir) && within(dir, readings.get(folder2)?.stop ?? folder2);
+    if (folders !== void 0 && within(folders, places.home)) {
+      const path = join5(folders, AGENTS_MD);
+      add({
+        path,
+        name: this.crumbs(path),
+        title: "For every OpenCode agent",
+        about: this.tilde(path),
+        editable: true,
+        id: "every-agent",
+        over: reaches(folders)
+      });
+    }
+    const yours = join5(places.config, AGENTS_MD);
+    for (const [folder2, reading] of readings) {
+      for (const dir of upTo(folder2, reading.stop).slice(1)) {
+        const path = join5(dir, AGENTS_MD);
+        if (path === yours || !isFile(path)) continue;
+        add({
+          path,
+          name: this.crumbs(path),
+          title: `From ${this.tilde(dir)}`.slice(0, 80),
+          about: this.tilde(path),
+          editable: false,
+          whyReadOnly: "It sits above the agents' folders.",
+          id: `above-${hashOf(path).slice(0, 12)}`,
+          over: reaches(dir)
+        });
+      }
+    }
+    if (isFile(yours)) {
+      add({
+        path: yours,
+        name: this.crumbs(yours),
+        title: "For all your OpenCode",
+        about: this.tilde(yours),
+        editable: false,
+        whyReadOnly: "Your own OpenCode reads it too.",
+        id: "yours"
+      });
+    }
+    for (const [folder2, reading] of readings) {
+      for (const path of reading.named) {
+        if (within(path, folder2)) continue;
+        add({
+          path,
+          name: this.crumbs(path),
+          title: "Named in OpenCode's config",
+          about: this.tilde(path),
+          editable: false,
+          whyReadOnly: "OpenCode's config names it for every session.",
+          id: `named-${hashOf(path).slice(0, 12)}`,
+          over: (other) => readings.get(other)?.named.includes(path) === true
+        });
+      }
+    }
+    return spots;
+  }
+  /** An agent's own files: its folder's `AGENTS.md`, and the named files in its folder. */
+  ownSpots(folder2, reading) {
+    const named = reading.named.filter((path) => within(path, folder2) && path !== join5(folder2, AGENTS_MD));
+    return [
+      { path: join5(folder2, AGENTS_MD), name: AGENTS_MD, title: "How it works", editable: true },
+      ...named.map((path) => ({
+        path,
+        name: relative(folder2, path).split(sep2).join(" \u203A ").slice(0, 255),
+        title: "Named in OpenCode's config",
+        editable: true
+      }))
+    ];
+  }
+  /** The shared files an agent in `folder` reads. */
+  readBy(folder2, reading) {
+    return this.sharedSpots(/* @__PURE__ */ new Map([[folder2, reading]])).filter((spot) => spot.over === void 0 || spot.over(folder2));
+  }
+  /** An agent's copy: its own files and the shared ones it reads, eight at most. */
+  agentCopy(folder2, reading) {
+    const rows = [];
+    const notShown = [];
+    const add = (row, text2) => {
+      const named = { name: row["name"], title: row["title"] };
+      if (text2 !== void 0 && contextBytes(text2) > CONTEXT_FILE_BYTES) notShown.push({ ...named, reason: "too_large" });
+      else if (rows.length >= CONTEXT_FILES_SHOWN) notShown.push({ ...named, reason: "count" });
+      else rows.push(row);
+    };
+    for (const spot of this.ownSpots(folder2, reading)) {
+      const text2 = textOf(spot.path) ?? "";
+      add({ name: spot.name, title: spot.title, role: "instructions", text: text2, hash: hashOf(text2), editable: true }, text2);
+    }
+    for (const spot of this.readBy(folder2, reading)) {
+      add({
+        name: spot.name,
+        title: spot.title,
+        role: "instructions",
+        ...spot.about === void 0 ? {} : { about: spot.about },
+        shared: spot.id,
+        replaceable: false,
+        editable: false
+      });
+    }
+    return { files: rows, ...notShown.length === 0 ? {} : { not_shown: notShown } };
+  }
+  /** The harness's own set, each file with how many of its agents (by their folders' readings) read it. */
+  harnessCopy(readings, agentFolders) {
+    const shared = [];
+    const notShown = [];
+    for (const spot of this.sharedSpots(readings)) {
+      const text2 = textOf(spot.path) ?? "";
+      const named = { name: spot.name, title: spot.title };
+      if (contextBytes(text2) > CONTEXT_FILE_BYTES) {
+        notShown.push({ ...named, reason: "too_large" });
+        continue;
+      }
+      if (shared.length >= CONTEXT_FILES_SHOWN) {
+        notShown.push({ ...named, reason: "count" });
+        continue;
+      }
+      const over = spot.over;
+      shared.push({
+        id: spot.id,
+        name: spot.name,
+        title: spot.title,
+        role: "instructions",
+        ...spot.about === void 0 ? {} : { about: spot.about },
+        text: text2,
+        hash: hashOf(text2),
+        editable: spot.editable,
+        ...spot.whyReadOnly === void 0 ? {} : { why_read_only: spot.whyReadOnly },
+        used_by: over === void 0 ? agentFolders.length : agentFolders.filter(over).length
+      });
+    }
+    return { shared, ...notShown.length === 0 ? {} : { not_shown: notShown } };
+  }
+  /**
+   * A person's edit of one of an agent's files, saved where OpenCode reads it, only if it is still
+   * the version they changed. Refused, with the copy as it is, for a file that isn't the agent's own
+   * to change, and as `changed` for one changed since.
+   */
+  async saveAgent(folder2, reading, edit) {
+    const now = () => this.agentCopy(folder2, reading);
+    const spot = this.ownSpots(folder2, reading).find((each) => each.name === edit.name);
+    if (spot === void 0) {
+      const shared = this.readBy(folder2, reading).some((each) => each.name === edit.name);
+      throw new Refuse(
+        shared ? "Every agent reads this one. Change it on OpenCode's page." : `There is no file called ${edit.name} here.`,
+        now(),
+        "failed"
+      );
+    }
+    if (edit.base_hash === null) throw new Refuse("This file is the agent's own already.", now(), "failed");
+    await this.write(spot, edit, now);
+  }
+  /** A person's edit of one of the harness's own files, read by its agents beside their own. */
+  async saveShared(readings, agentFolders, edit) {
+    const now = () => this.harnessCopy(readings, agentFolders);
+    const spot = this.sharedSpots(readings).find((each) => each.name === edit.name);
+    if (spot === void 0) throw new Refuse(`There is no file called ${edit.name} here.`, now(), "failed");
+    if (!spot.editable) throw new Refuse(spot.whyReadOnly ?? "It can't be changed from Chips.", now(), "failed");
+    if (edit.base_hash === null) {
+      throw new Refuse("Every agent reads this file beside its own, so none can have its own in its place.", now(), "failed");
+    }
+    await this.write(spot, edit, now);
+  }
+  async write(spot, edit, now) {
+    if (hashOf(textOf(spot.path) ?? "") !== edit.base_hash) throw new Refuse("", now(), "changed");
+    try {
+      await mkdir2(dirname4(spot.path), { recursive: true });
+      await writeFile2(spot.path, edit.text, "utf8");
+    } catch (error62) {
+      throw new Refuse(`It couldn't be saved: ${error62 instanceof Error ? error62.message : String(error62)}`.slice(0, 300), now(), "failed");
+    }
+  }
+};
 
 // src/opencode.ts
 var OpenCodeError = class extends Error {
@@ -25507,12 +25770,47 @@ var OpenCodeClient = class {
       return false;
     }
   }
+  /** Which OpenCode answers: `GET /api/info`'s `version`, `2.0.25`. */
+  async version() {
+    const info = await this.call("GET", "/api/info");
+    return typeof info["version"] === "string" ? info["version"] : "";
+  }
+  /** The root of the project a folder is in, as OpenCode has it: the folder itself, outside any repository. */
+  async projectRoot(directory) {
+    const read = await this.call("GET", `/api/location${whereIs(directory)}`);
+    const project = read["project"] ?? {};
+    return typeof project["directory"] === "string" ? project["directory"] : directory;
+  }
+  /**
+   * The instruction files the config documents for a folder name (`instructions`), each document's
+   * in turn, each named once: a path, a glob or a URL, as written.
+   */
+  async instructions(directory) {
+    const answer = await this.fetcher(`${this.root}/api/config${whereIs(directory)}`, { headers: { authorization: this.auth } });
+    if (!answer.ok) throw await failureOf(answer);
+    const entries = await answer.json();
+    const named = (Array.isArray(entries) ? entries : []).filter((entry) => entry["type"] === "document").flatMap((entry) => (entry["info"] ?? {})["instructions"]).filter((each) => typeof each === "string");
+    return [...new Set(named)];
+  }
   async agents() {
     return await this.catalogue("agent");
   }
   async models() {
     return await this.catalogue("model");
   }
+  /** The model a session with none of its own runs on, when the server has one. */
+  async defaultModel() {
+    const read = await this.call("GET", `/api/model/default${this.where()}`);
+    const data = read["data"];
+    return typeof data === "object" && data !== null ? data : void 0;
+  }
+  /**
+   * The model a session runs on from its next model call. OpenCode takes any model and level
+   * here, one it can't run among them, so the bridge asks only for those of its catalogue.
+   */
+  async setModel(sessionId, model) {
+    await this.call("POST", `/api/session/${encodeURIComponent(sessionId)}/model`, { model });
+  }
   /**
    * A project's catalogue. OpenCode 2.0 answers the first ask for a project it hasn't loaded with
    * an empty list, and the next with the whole one: a server always has its `build` agent, so an
@@ -25577,6 +25875,13 @@ var OpenCodeClient = class {
     if (typeof id2 !== "string") throw new OpenCodeError("OpenCode took the words and named no inbox item", 502);
     return id2;
   }
+  /**
+   * Compact a session: its inbox takes the ask, which starts at once when it is idle and at its next
+   * step when it is working. `session.compaction.started` and `.ended` or `.failed` say how it goes.
+   */
+  async compact(sessionId) {
+    await this.call("POST", `/api/session/${encodeURIComponent(sessionId)}/compact`, {});
+  }
   /** Words the session hasn't taken yet, taken back. */
   async withdraw(sessionId, item) {
     await this.call("DELETE", `/api/session/${encodeURIComponent(sessionId)}/inbox/${encodeURIComponent(item)}`);
@@ -25626,6 +25931,22 @@ var OpenCodeClient = class {
     const content = Array.isArray(newest?.["content"]) ? newest["content"] : [];
     return content.filter((part) => part["type"] === "text" && typeof part["text"] === "string").map((part) => String(part["text"])).join("\n\n");
   }
+  /** The tokens and model of a session's newest model call, and when: nothing for a session with none. */
+  async lastCall(sessionId) {
+    const read = await this.call(
+      "GET",
+      `/api/session/${encodeURIComponent(sessionId)}/message?type=assistant&order=desc&limit=1`
+    );
+    const newest = (Array.isArray(read["data"]) ? read["data"] : [])[0];
+    const tokens2 = newest?.["tokens"];
+    if (typeof tokens2 !== "object" || tokens2 === null) return void 0;
+    const time3 = newest?.["time"] ?? {};
+    return {
+      tokens: tokens2,
+      ...typeof newest?.["model"] === "object" && newest["model"] !== null ? { model: newest["model"] } : {},
+      at: typeof time3["created"] === "number" ? time3["created"] : 0
+    };
+  }
   /** Every event the server sends, each handed to `hear` as it comes, until the stream ends. */
   async events(hear, signal) {
     const answer = await this.fetcher(`${this.root}/api/event`, {
@@ -25649,7 +25970,7 @@ var OpenCodeClient = class {
   /** `?location[directory]=…` for the catalogues, which are per project. */
   where() {
     const directory = this.address.directory;
-    return directory === void 0 ? "" : `?location%5Bdirectory%5D=${encodeURIComponent(directory)}`;
+    return directory === void 0 ? "" : whereIs(directory);
   }
   async call(method, path, body) {
     const answer = await this.fetcher(`${this.root}${path}`, {
@@ -25665,6 +25986,9 @@ var OpenCodeClient = class {
     return text2 === "" ? {} : JSON.parse(text2);
   }
 };
+function whereIs(directory) {
+  return `?location%5Bdirectory%5D=${encodeURIComponent(directory)}`;
+}
 function eventOf(block) {
   const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
   if (data === "") return void 0;
@@ -25696,18 +26020,138 @@ async function failureOf(answer) {
   return new OpenCodeError(message, answer.status, tag, kind);
 }
 
+// src/models.ts
+var MODEL_CHOICES_MAX2 = 40;
+var EFFORT_LEVELS_MAX2 = 8;
+var LEVEL_WORDS = {
+  none: "None",
+  minimal: "Minimal",
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+  max: "Max",
+  thinking: "Thinking"
+};
+function writtenOf(model) {
+  return `${model.providerID}/${model.id}`;
+}
+function refOf(pick2) {
+  return { ...modelRefOf(pick2.model), ...pick2.effort === void 0 ? {} : { variant: pick2.effort } };
+}
+function levelOf(model) {
+  return model?.variant === void 0 || model.variant === "default" ? void 0 : model.variant;
+}
+function sameModel(a, b) {
+  return a?.providerID === b?.providerID && a?.id === b?.id && levelOf(a) === levelOf(b);
+}
+function levelWords(id2) {
+  return (LEVEL_WORDS[id2] ?? `${id2.charAt(0).toUpperCase()}${id2.slice(1)}`).slice(0, 40);
+}
+function runnable(catalogue) {
+  return catalogue.filter((model) => model.enabled !== false && model.status !== "deprecated");
+}
+function levelsOf(model) {
+  const seen = /* @__PURE__ */ new Set();
+  const each = (model?.variants ?? []).filter((variant) => !seen.has(variant.id) && seen.add(variant.id));
+  return each.slice(-EFFORT_LEVELS_MAX2).map((variant) => ({ id: variant.id, label: levelWords(variant.id) }));
+}
+var fitting = (choice, effort) => choice?.efforts.some((level) => level.id === effort) === true ? effort : void 0;
+function modelCopy(input2) {
+  const { pick: pick2, fallback } = input2;
+  const runsOn = pick2 === void 0 ? fallback?.model : refOf(pick2);
+  if (runsOn === void 0) return void 0;
+  const offered2 = runnable(input2.catalogue);
+  const names = /* @__PURE__ */ new Map();
+  for (const model of offered2) names.set(model.name, (names.get(model.name) ?? 0) + 1);
+  const choices = offered2.map((model) => ({
+    id: writtenOf(model),
+    label: ((names.get(model.name) ?? 0) > 1 ? `${model.name} \xB7 ${model.providerID}` : model.name || model.id).slice(0, 80),
+    efforts: levelsOf(model)
+  }));
+  const named = (ref) => {
+    const id2 = writtenOf(ref);
+    const known = choices.find((choice2) => choice2.id === id2);
+    if (known !== void 0) return known;
+    const level = levelOf(ref);
+    const choice = { id: id2, label: ref.id.slice(0, 80), efforts: level === void 0 ? [] : [{ id: level, label: levelWords(level) }] };
+    choices.push(choice);
+    return choice;
+  };
+  const now = named(runsOn);
+  const otherwise = fallback === void 0 ? void 0 : named(fallback.model);
+  const effort = fitting(now, levelOf(runsOn));
+  const fallbackEffort = fitting(otherwise, levelOf(fallback?.model));
+  const keep = /* @__PURE__ */ new Set([now.id, ...otherwise === void 0 ? [] : [otherwise.id]]);
+  let others = MODEL_CHOICES_MAX2 - keep.size;
+  return {
+    model: now.id,
+    ...effort === void 0 ? {} : { effort },
+    own: pick2 !== void 0,
+    ...fallback === void 0 || otherwise === void 0 ? {} : {
+      default: {
+        label: fallback.label.slice(0, 80),
+        model: otherwise.id,
+        ...fallbackEffort === void 0 ? {} : { effort: fallbackEffort }
+      }
+    },
+    choices: choices.filter((choice) => keep.has(choice.id) || others-- > 0),
+    editable: true
+  };
+}
+function pickOf(change, catalogue) {
+  if (change.model === null) return null;
+  const model = runnable(catalogue).find((each) => writtenOf(each) === change.model);
+  if (model === void 0) throw new Error(`OpenCode doesn't run ${change.model} here.`);
+  if (change.effort === null) return { model: change.model };
+  if (!(model.variants ?? []).some((variant) => variant.id === change.effort)) {
+    throw new Error(`${model.name || model.id} has no ${levelWords(change.effort)} level.`);
+  }
+  return { model: change.model, effort: change.effort };
+}
+
+// src/windows.ts
+var OWN_LIMIT = "OpenCode compacts it itself when it is nearly full, as its config says.";
+function usedOf(tokens2) {
+  return tokens2.input + tokens2.cache.read + tokens2.cache.write + tokens2.output + tokens2.reasoning;
+}
+function compactedTo(data) {
+  const tokens2 = data["tokens"];
+  const summary = typeof tokens2?.output === "number" ? tokens2.output : 0;
+  const recent = typeof data["recent"] === "string" ? data["recent"] : "";
+  return Math.round(summary + recent.length / 4);
+}
+function windowCopy(kept, compacting) {
+  return {
+    used: Math.max(0, Math.round(kept.used)),
+    window: Math.max(1, Math.round(kept.window)),
+    ...kept.model === void 0 ? {} : { model: kept.model.slice(0, 120) },
+    as_of: kept.asOf,
+    ...compacting === void 0 ? {} : { compacting },
+    ...kept.last === void 0 ? {} : { last: kept.last },
+    ...kept.longTurn === void 0 ? {} : { long_turn: { ...kept.longTurn, folds: Math.min(kept.longTurn.folds, LONG_TURN_FOLDS_MAX) } },
+    compacts: true,
+    editable: false,
+    why_read_only: OWN_LIMIT
+  };
+}
+
 // src/bridge.ts
-var WANTS = ["agents", "new_agents", "forks"];
+var WANTS = ["agents", "new_spaces", "new_agents", "forks", "models", "context_files", "context_windows"];
+function wantsFor(ownServer2) {
+  return ownServer2 ? [...WANTS, "restarts"] : WANTS;
+}
 function freeFolder(root, name, taken) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
   for (let count = 1; ; count += 1) {
-    const folder2 = join5(root, count === 1 ? slug : `${slug}-${count}`);
+    const folder2 = join6(root, count === 1 ? slug : `${slug}-${count}`);
     if (!taken.includes(folder2)) return folder2;
   }
 }
 var ids = createIdGenerator();
 var QUIET_MS = 1500;
 var INTERRUPTING = "interrupting";
+var TROUBLE_CHARS = 200;
 var LOOKS_KEPT = 500;
 var REPLY_CHARS = 1500;
 var KINDS = {
@@ -25731,6 +26175,9 @@ var Bridge = class {
   constructor(options) {
     this.options = options;
     this.log = options.log ?? (() => void 0);
+    this.places = options.places ?? placesOf(process.env, homedir4());
+    const known = options.folders !== void 0 || options.directory !== void 0;
+    this.files = known ? new ContextFiles(this.places, options.folders) : void 0;
   }
   options;
   agents = [];
@@ -25760,6 +26207,21 @@ var Bridge = class {
   health;
   listening = new AbortController();
   connections = 0;
+  /** Opens the event stream again now, rather than once its wait is over. */
+  wake;
+  /** A person's Restart under way: nothing is said of how it is meanwhile (Chips ADR 0094). */
+  restarting;
+  /** Why OpenCode's server isn't there, where the bridge knows more than that it doesn't answer. */
+  why;
+  /** The files OpenCode builds each agent from, where the bridge knows each agent's folder. */
+  files;
+  places;
+  /** Each folder's project root, as OpenCode said it. */
+  roots = /* @__PURE__ */ new Map();
+  /** Whether the server reads the files its config's `instructions` names, asked once a start or a restart. */
+  readsNamed;
+  /** Agents compacting now, by whose sessions they are: waiting for their session's next step, or under way, and the ask from Chips. */
+  compacting = /* @__PURE__ */ new Map();
   /** Register the agents, start hearing OpenCode and what is said in Chips, and say how it is. */
   async start() {
     const { chips: chips2 } = this.options;
@@ -25779,9 +26241,17 @@ var Bridge = class {
     chips2.on("agent.fork", (fork) => {
       this.copy(fork).catch((error62) => this.log(`a copy went wrong: ${messageOf(error62)}`));
     });
+    chips2.onSpaceAsked((asked) => {
+      this.claim(asked).catch((error62) => this.log(`a space from the + went wrong: ${messageOf(error62)}`));
+    });
     chips2.on("feedback", (feedback2) => {
       this.notRight(feedback2).catch((error62) => this.log(`a second look went wrong: ${messageOf(error62)}`));
     });
+    for (const agent of await chips2.agents.list().catch(() => [])) {
+      if (agent.state !== "archived") await this.sendModel(agent.agentId);
+    }
+    await this.sendContexts();
+    await this.sendWindows();
     await this.sayHowItIs();
     this.health = setInterval(() => void this.sayHowItIs(), this.options.healthEveryMs ?? 3e4);
     this.health.unref();
@@ -25790,6 +26260,38 @@ var Bridge = class {
     if (this.health !== void 0) clearInterval(this.health);
     this.listening.abort();
   }
+  /**
+   * A person's Restart (Chips ADR 0094): the server stopped and started again, then how it is,
+   * fine or why not. Asked again meanwhile, it is the same restart. Nothing where the bridge
+   * doesn't run the server, which never says it hears restarts.
+   */
+  restart() {
+    this.restarting ??= (async () => {
+      try {
+        await this.restartServer();
+      } finally {
+        this.restarting = void 0;
+      }
+      await this.sayHowItIs();
+    })();
+    return this.restarting;
+  }
+  async restartServer() {
+    const again2 = this.options.restartServer;
+    if (again2 === void 0) return;
+    this.log("a person asked for a restart");
+    try {
+      await again2();
+      this.why = void 0;
+      this.readsNamed = void 0;
+      this.wake?.();
+    } catch (error62) {
+      const why = messageOf(error62).replace(/\s+/g, " ").trim();
+      this.why = why.length <= TROUBLE_CHARS ? why : `${why.slice(0, TROUBLE_CHARS - 1)}\u2026`;
+      this.log(`OpenCode's server isn't back: ${why}`);
+      for (const turn of this.turns.values()) turn.end({ outcome: "failed", why: "OpenCode didn't come back after a restart" });
+    }
+  }
   /** The Main agent, the first registered, once started: who says the harness's first words. */
   get mainAgentId() {
     return this.agents[0]?.agentId;
@@ -25803,16 +26305,16 @@ var Bridge = class {
    */
   async seatMain(config3, known) {
     const { chips: chips2 } = this.options;
-    const before = known.find((agent) => agent.lead);
+    const before2 = 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 (!made && before2 !== void 0) {
+      await this.goHome(before2, known);
+      return before2;
     }
     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)}`));
+    if (before2 !== void 0 && before2.agentId !== main2.agentId) {
+      await chips2.agents.register({ key: before2.key, name: before2.name, state: "archived" }).catch((error62) => this.log(`${before2.name} stays: ${String(error62)}`));
     }
     return main2;
   }
@@ -25823,11 +26325,17 @@ var Bridge = class {
     const there = known.find((agent) => agent.agentId !== main2.agentId && agent.spaces.includes(home3));
     await chips2.agents.attach(main2.agentId, { spaceId: home3, replacing: there?.agentId ?? chips2.harnessId }).catch((error62) => this.log(`${main2.name} stays out of its home: ${String(error62)}`));
   }
-  /** Trouble while the server doesn't answer, and fine once it does (ADR 0083). */
+  /**
+   * Trouble while the server doesn't answer, and fine once it does (ADR 0083). Nothing while a
+   * restart is under way: its end says (ADR 0094).
+   */
   async sayHowItIs() {
+    if (this.restarting !== void 0) return;
     const up = await this.options.opencode.healthy();
+    if (this.restarting !== void 0) return;
+    if (up) this.why = void 0;
     const chips2 = this.options.chips;
-    await (up ? chips2.reportOk() : chips2.reportTrouble("OpenCode isn't answering")).catch(() => void 0);
+    await (up ? chips2.reportOk() : chips2.reportTrouble(this.why ?? "OpenCode isn't answering")).catch(() => void 0);
   }
   /** OpenCode's event stream, opened again whenever it drops, a little later each time it fails. */
   async listen() {
@@ -25841,8 +26349,15 @@ var Bridge = class {
         if (this.listening.signal.aborted) return;
         this.log(`OpenCode's events: ${messageOf(error62)}`);
       }
-      await new Promise((resolve5) => setTimeout(resolve5, wait2));
-      wait2 = Math.min(wait2 * 2, 15e3);
+      const woken = await new Promise((resolve5) => {
+        const timer = setTimeout(() => resolve5(false), wait2);
+        this.wake = () => {
+          clearTimeout(timer);
+          resolve5(true);
+        };
+      });
+      this.wake = void 0;
+      wait2 = woken ? first : Math.min(wait2 * 2, 15e3);
     }
   }
   /**
@@ -25861,6 +26376,47 @@ var Bridge = class {
     });
     this.ours.add(agent.agentId);
     this.log(`${agent.name} made${agent.attached === false ? `, not in the room: ${agent.why ?? "too late"}` : ""}`);
+    await this.sendModel(agent.agentId);
+    await this.sendContexts();
+  }
+  /**
+   * A space a person asked for from Chips's + (Chips ADR 0241), or beside another harness: claimed
+   * under a key of its own, named from its first words, and Chips makes the new agent the key is
+   * for and puts it in the space. That agent answers the first words, which are the ask's and are
+   * not heard again as a message, as the first OpenCode agent, in a session and a folder of its
+   * own. A claim heard again finds the space claimed already, and the agent the same.
+   */
+  async claim(asked) {
+    const { chips: chips2 } = this.options;
+    const { spaceId, firstMessage } = asked;
+    const key = `opencode: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.ours.add(agent.agentId);
+    this.log(`${agent.name} claimed ${spaceId}`);
+    await this.sendModel(agent.agentId);
+    await this.sendContexts();
+    const context = await chips2.roomContext(spaceId, { limit: 20 }).catch(() => void 0);
+    const said = context?.lines.find((line) => line.message_id === firstMessage.messageId)?.from;
+    const message = {
+      type: "message.new",
+      space_id: spaceId,
+      message_id: firstMessage.messageId,
+      text: firstMessage.text,
+      from: {
+        participant_id: asked.askedBy,
+        kind: "person",
+        display_name: said?.name ?? "Someone",
+        role: said?.role ?? "member",
+        ...said?.workspace_role === void 0 ? {} : { workspace_role: said.workspace_role }
+      },
+      for: [agent.agentId]
+    };
+    await this.hear(message);
   }
   /** A person's Fork, made once however often it is heard at a time. */
   copy(fork) {
@@ -25922,6 +26478,8 @@ var Bridge = class {
     this.ours.add(copy.agentId);
     if (kept.session !== void 0) state2.sessions[`${copy.agentId}|${spaceId}`] = kept.session;
     if (kept.folder !== void 0) state2.folders = { ...state2.folders, [copy.agentId]: kept.folder };
+    const pick2 = state2.models?.[who];
+    if (pick2 !== void 0) state2.models = { ...state2.models, [copy.agentId]: pick2 };
     saveState(state2);
     if (copied !== void 0) {
       await opencode2.update(copied.id, {
@@ -25932,6 +26490,7 @@ var Bridge = class {
     this.log(
       `${copy.name}, a copy of ${name}, made${kept.session === void 0 ? " new" : ` from ${kept.session}`}${copy.attached === false && copy.why !== void 0 ? `; not in the room: ${copy.why}` : ""}`
     );
+    void this.sendModel(copy.agentId).then(() => this.sendContexts());
   }
   /** The session of an agent's to copy: its room's, or where it is in none, the last it had. */
   sessionToCopy(who, room) {
@@ -25939,6 +26498,304 @@ var Bridge = class {
     if (room !== void 0 && room !== null) return sessions[`${who}|${room}`];
     return Object.entries(sessions).findLast(([id2]) => id2.startsWith(`${who}|`))?.[1];
   }
+  // ------------------------------------------------------------------ what a person changes from an agent's page
+  /**
+   * Which OpenCode agent a Chips agent of the harness's runs as, and whose its sessions and its
+   * pick are, as `roomOf` says: the key of one configured here, else its Chips id. Nothing for an
+   * agent not the harness's.
+   */
+  async whoseIs(agentId2) {
+    const agent = await this.runnerOf(agentId2);
+    if (agent === void 0 || agentId2 === this.options.chips.harnessId) return void 0;
+    return { agent, who: agentId2 === agent.agentId ? agent.key : agentId2 };
+  }
+  /**
+   * What an agent runs on with no pick of its own: its model in the bridge's config, else its
+   * OpenCode agent's, else the server's default.
+   */
+  async fallbackOf(agent) {
+    if (agent.model !== void 0) return { model: agent.model, label: "As in config.json" };
+    const { opencode: opencode2 } = this.options;
+    const own2 = (await opencode2.agents().catch(() => [])).find((each) => each.id === agent.config.agent)?.model;
+    if (own2 !== void 0) return { model: own2, label: "OpenCode's default" };
+    const model = await opencode2.defaultModel();
+    return model === void 0 ? void 0 : { model: { providerID: model.providerID, id: model.id }, label: "OpenCode's default" };
+  }
+  /** An agent's model, as OpenCode and the bridge have it now: nothing for an agent not the harness's. */
+  async modelCopyOf(agentId2) {
+    const whose = await this.whoseIs(agentId2);
+    if (whose === void 0) return void 0;
+    const [catalogue, fallback] = await Promise.all([this.options.opencode.models(), this.fallbackOf(whose.agent)]);
+    return modelCopy({ catalogue, pick: this.options.state.models?.[whose.who], fallback });
+  }
+  /** An agent's model sent, where it changed since it last was (Chips takes the same copy once). */
+  async sendModel(agentId2) {
+    try {
+      const copy = await this.modelCopyOf(agentId2);
+      if (copy !== void 0) await this.options.chips.settings.model(agentId2, copy);
+    } catch (error62) {
+      this.log(`the model of ${agentId2} not sent: ${messageOf(error62)}`);
+    }
+  }
+  /**
+   * A person's pick of an agent's model and level from its page (Chips ADR 0241): kept with the
+   * bridge's state, and given to each of its sessions before its next message there. Only a model
+   * OpenCode runs, at one of its levels; `null` is its default again. Answered with its copy.
+   */
+  async modelChanged(change) {
+    const whose = await this.whoseIs(change.agent_id);
+    if (whose === void 0) throw new Refuse("This harness has no such agent.");
+    const { opencode: opencode2, state: state2, saveState } = this.options;
+    let pick2;
+    try {
+      pick2 = pickOf(change, await opencode2.models());
+    } catch (error62) {
+      throw new Refuse(messageOf(error62), await this.modelCopyOf(change.agent_id).catch(() => void 0));
+    }
+    const models = { ...state2.models };
+    if (pick2 === null) delete models[whose.who];
+    else models[whose.who] = pick2;
+    state2.models = models;
+    saveState(state2);
+    const name = await this.nameOf(whose);
+    this.log(`${name} runs on ${pick2 === null ? "its default" : `${pick2.model}${pick2.effort === void 0 ? "" : ` at ${pick2.effort}`}`}, from Chips`);
+    const copy = await this.modelCopyOf(change.agent_id);
+    if (copy === void 0) throw new Refuse("OpenCode names no model for it.");
+    return copy;
+  }
+  /**
+   * The session a message goes to, put on the model its agent runs on, where it isn't on it
+   * already (Chips ADR 0241): its pick, else its model in the bridge's config. A session that was
+   * put on another before, with neither now, goes back to its OpenCode agent's or the server's.
+   */
+  async modelled(sessionId, { who, agent }) {
+    const { opencode: opencode2, state: state2 } = this.options;
+    const pick2 = state2.models?.[who];
+    try {
+      const has = (await opencode2.session(sessionId))["model"];
+      const want = pick2 !== void 0 ? refOf(pick2) : agent.model ?? (has === void 0 ? void 0 : (await this.fallbackOf(agent))?.model);
+      if (want === void 0 || sameModel(want, has)) return;
+      await opencode2.setModel(sessionId, want);
+      this.log(`${sessionId} runs on ${writtenOf(want)}${want.variant === void 0 ? "" : ` at ${want.variant}`} from now`);
+    } catch (error62) {
+      if (!(error62 instanceof OpenCodeError && error62.tag === "SessionNotFoundError")) {
+        this.log(`${sessionId} stays on its model: ${messageOf(error62)}`);
+      }
+    }
+  }
+  /** The folder an agent's sessions work in, its own or the one project's; none where the bridge knows neither. */
+  async agentFolder(whose) {
+    return await this.folderFor(whose) ?? this.options.directory;
+  }
+  /**
+   * What OpenCode reads for a folder beside its `AGENTS.md` files: where its walk up stops, and
+   * from 2.0.30 the files its config's `instructions` names. A folder whose project OpenCode can't
+   * say is its own project.
+   */
+  async readingOf(folder2) {
+    const { opencode: opencode2 } = this.options;
+    const { home: home3 } = this.places;
+    let root = this.roots.get(folder2);
+    if (root === void 0) {
+      root = await opencode2.projectRoot(folder2).catch(() => folder2);
+      this.roots.set(folder2, root);
+    }
+    this.readsNamed ??= opencode2.version().then(
+      (version3) => !before(version3, READS_NAMED),
+      () => false
+    );
+    const sources = await this.readsNamed ? await opencode2.instructions(folder2).catch(() => []) : [];
+    return { stop: within(folder2, home3) ? home3 : root, named: namedFiles(sources, folder2, root, home3) };
+  }
+  /** Each agent of the harness's, with the folder its sessions work in and what OpenCode reads there. */
+  async agentReadings() {
+    const read = [];
+    for (const agent of await this.options.chips.agents.list().catch(() => [])) {
+      if (agent.state === "archived") continue;
+      const whose = await this.whoseIs(agent.agentId);
+      const folder2 = whose === void 0 ? void 0 : await this.agentFolder(whose);
+      if (folder2 !== void 0) read.push({ agentId: agent.agentId, folder: folder2, reading: await this.readingOf(folder2) });
+    }
+    return read;
+  }
+  /** The harness's own set and each agent's files, as they are on disk now: each sent where it changed. */
+  async sendContexts() {
+    const files = this.files;
+    if (files === void 0) return;
+    try {
+      const read = await this.agentReadings();
+      const readings = new Map(read.map((each) => [each.folder, each.reading]));
+      await this.options.chips.settings.harnessContext(files.harnessCopy(readings, read.map((each) => each.folder)));
+      for (const { agentId: agentId2, folder: folder2, reading } of read) {
+        await this.options.chips.settings.context(agentId2, files.agentCopy(folder2, reading));
+      }
+    } catch (error62) {
+      this.log(`the agents' files not sent: ${messageOf(error62)}`);
+    }
+  }
+  /** One agent's files sent, where they changed. */
+  async sendContext(agentId2) {
+    const whose = await this.whoseIs(agentId2);
+    const folder2 = whose === void 0 ? void 0 : await this.agentFolder(whose);
+    if (this.files === void 0 || folder2 === void 0) return;
+    try {
+      await this.options.chips.settings.context(agentId2, this.files.agentCopy(folder2, await this.readingOf(folder2)));
+    } catch (error62) {
+      this.log(`the files of ${agentId2} not sent: ${messageOf(error62)}`);
+    }
+  }
+  /**
+   * A person's edit of a file from Chips (Chips ADR 0134): saved where OpenCode reads it, only if
+   * it is still the version they changed, and answered with the copy as it is now. OpenCode reads
+   * it again before the agent's next model call, and tells the agent what changed: every agent
+   * working in that folder, or for the harness's own set every agent that reads the file.
+   */
+  async contextEdited(edit) {
+    const files = this.files;
+    if (files === void 0) throw new Refuse("This bridge doesn't know where its agents' files are.");
+    if (edit.agent_id === void 0) {
+      const read = await this.agentReadings();
+      const readings = new Map(read.map((each) => [each.folder, each.reading]));
+      const folders = read.map((each) => each.folder);
+      await files.saveShared(readings, folders, edit);
+      this.log(`OpenCode's ${edit.name} saved from Chips`);
+      return files.harnessCopy(readings, folders);
+    }
+    const whose = await this.whoseIs(edit.agent_id);
+    const folder2 = whose === void 0 ? void 0 : await this.agentFolder(whose);
+    if (whose === void 0 || folder2 === void 0) throw new Refuse("This harness has no such agent.");
+    const reading = await this.readingOf(folder2);
+    await files.saveAgent(folder2, reading, edit);
+    this.log(`${await this.nameOf(whose)}'s ${edit.name} saved from Chips`);
+    for (const other of await this.agentReadings()) {
+      if (other.agentId !== edit.agent_id && other.folder === folder2) void this.sendContext(other.agentId);
+    }
+    return files.agentCopy(folder2, reading);
+  }
+  // ------------------------------------------------------------------ how full each agent is (Chips ADRs 0146, 0241)
+  /** The Chips agent whose sessions are `who`'s: a configured agent's, or the agent itself. */
+  agentIdOf(who) {
+    return this.agents.find((agent) => agent.key === who)?.agentId ?? who;
+  }
+  /** Whose a session is, by the rooms the bridge keeps: nothing for one it didn't make. */
+  whoseSession(sessionId) {
+    const id2 = Object.entries(this.options.state.sessions).find(([, each]) => each === sessionId)?.[0];
+    return id2?.slice(0, id2.lastIndexOf("|"));
+  }
+  /** An agent's window copy sent, and kept with the bridge's state: nothing until it has said how full it is. */
+  async sendWindow(who) {
+    const kept = this.options.state.windows?.[who];
+    if (kept === void 0) return;
+    this.options.saveState(this.options.state);
+    await this.options.chips.settings.contextWindow(this.agentIdOf(who), windowCopy(kept, this.compacting.get(who)?.state)).catch((error62) => this.log(`the context window of ${who} not sent: ${messageOf(error62)}`));
+  }
+  /**
+   * Each agent's window as it last said, at start. One the bridge kept nothing of, from before it
+   * kept them, is read from the newest model call of its sessions.
+   */
+  async sendWindows() {
+    const { opencode: opencode2, state: state2 } = this.options;
+    const whose = new Set(Object.keys(state2.sessions).map((id2) => id2.slice(0, id2.lastIndexOf("|"))));
+    for (const who of whose) {
+      if (state2.windows?.[who] === void 0) {
+        let newest;
+        for (const [id2, sessionId] of Object.entries(state2.sessions)) {
+          if (!id2.startsWith(`${who}|`)) continue;
+          const call = await opencode2.lastCall(sessionId).catch(() => void 0);
+          if (call !== void 0 && (newest === void 0 || call.at > newest.call.at)) newest = { sessionId, call };
+        }
+        const model = newest?.call.model === void 0 ? void 0 : writtenOf(newest.call.model);
+        const window = model === void 0 ? void 0 : await this.windowOf(model);
+        if (newest === void 0 || model === void 0 || window === void 0) continue;
+        const asOf = new Date(newest.call.at > 0 ? newest.call.at : Date.now()).toISOString();
+        state2.windows = { ...state2.windows, [who]: { used: usedOf(newest.call.tokens), window, model, asOf, session: newest.sessionId } };
+      }
+      await this.sendWindow(who);
+    }
+  }
+  /** A turn ended: how full it got, where that passed half the window, and the copy as it is now. */
+  async turnHeld(turn) {
+    const kept = this.options.state.windows?.[turn.who];
+    if (kept === void 0) return;
+    if (turn.peak > kept.window / 2) {
+      kept.longTurn = { at: (/* @__PURE__ */ new Date()).toISOString(), peak: Math.round(turn.peak), folds: turn.folds };
+    }
+    await this.sendWindow(turn.who);
+  }
+  /**
+   * What OpenCode says of a compaction of one of the agents' sessions: under way, done, with how
+   * much it held before and after, or failed. A Compact now asked from Chips that failed is
+   * refused after all, in OpenCode's words.
+   */
+  compactionHeard(sessionId, event) {
+    const who = this.whoseSession(sessionId);
+    const kept = who === void 0 ? void 0 : this.options.state.windows?.[who];
+    if (who === void 0 || kept === void 0) return;
+    const asked = this.compacting.get(who);
+    if (event.type === "session.compaction.started") {
+      if (asked === void 0) this.compacting.set(who, { state: "running" });
+      else asked.state = "running";
+      void this.sendWindow(who);
+      return;
+    }
+    if (event.type === "session.compaction.ended") {
+      this.compacting.delete(who);
+      const to = compactedTo(event.data);
+      const by = event.data["reason"] === "manual" ? "asked" : "itself";
+      kept.last = { at: (/* @__PURE__ */ new Date()).toISOString(), from: Math.round(kept.used), to, by };
+      kept.used = to;
+      kept.asOf = kept.last.at;
+      kept.session = sessionId;
+      const turn = this.turns.get(sessionId);
+      if (turn !== void 0 && by === "itself") turn.folds += 1;
+      this.log(`${who} compacted (${by}), ${kept.last.from} to ${to} tokens`);
+      void this.sendWindow(who);
+      return;
+    }
+    if (event.type === "session.compaction.failed") {
+      this.compacting.delete(who);
+      const error62 = event.data["error"] ?? {};
+      const why = text(error62["message"]) ?? "OpenCode didn't compact it.";
+      this.log(`${who} not compacted: ${why}`);
+      if (asked?.changeId === void 0) {
+        void this.sendWindow(who);
+        return;
+      }
+      void this.options.chips.settings.contextWindowFailed(this.agentIdOf(who), asked.changeId, why, windowCopy(kept)).catch((failed) => this.log(`the context window of ${who} not sent: ${messageOf(failed)}`));
+    }
+  }
+  /**
+   * A person's Compact now (Chips ADR 0146): asked of OpenCode for the session the agent said it
+   * was in last, which takes it at once when idle and at its next step when working, and answered
+   * with the copy saying so. How it goes comes in OpenCode's own events.
+   */
+  async windowCompact(ask2) {
+    const whose = await this.whoseIs(ask2.agent_id);
+    if (whose === void 0) throw new Refuse("This harness has no such agent.");
+    const { who } = whose;
+    const kept = this.options.state.windows?.[who];
+    if (kept === void 0) throw new Refuse(`${await this.nameOf(whose)} hasn't said how full it is yet.`);
+    if (this.compacting.has(who)) throw new Refuse("It is compacting already.", windowCopy(kept, this.compacting.get(who)?.state));
+    const { opencode: opencode2 } = this.options;
+    const busy = this.turns.has(kept.session) || (await opencode2.active().catch(() => /* @__PURE__ */ new Set())).has(kept.session);
+    this.compacting.set(who, { state: busy ? "queued" : "running", changeId: ask2.change_id });
+    try {
+      await opencode2.compact(kept.session);
+    } catch (error62) {
+      this.compacting.delete(who);
+      throw new Refuse(`OpenCode didn't take it: ${messageOf(error62)}`, windowCopy(kept));
+    }
+    this.log(`${await this.nameOf(whose)} compacts ${busy ? "at its session's next step" : "now"}, from Chips`);
+    return windowCopy(kept, this.compacting.get(who)?.state);
+  }
+  /** A person's limit: OpenCode keeps its own, set in its config, and the copy says so. */
+  async windowChange(ask2) {
+    const whose = await this.whoseIs(ask2.agent_id);
+    const kept = whose === void 0 ? void 0 : this.options.state.windows?.[whose.who];
+    if (whose === void 0) throw new Refuse("This harness has no such agent.");
+    const copy = kept === void 0 ? void 0 : windowCopy(kept, this.compacting.get(whose.who)?.state);
+    throw new Refuse(copy?.why_read_only ?? "OpenCode keeps its own limit.", copy);
+  }
   // ------------------------------------------------------------------ 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, own2 = {}) {
@@ -26043,13 +26900,17 @@ var Bridge = class {
       return;
     }
     let end2 = () => void 0;
-    const ended = new Promise((resolve5) => {
+    const ended2 = new Promise((resolve5) => {
       end2 = resolve5;
     });
     const turn = {
       run: run2,
       speaker,
       agent,
+      who: room.who,
+      agentId: speakerId ?? agent.agentId,
+      peak: 0,
+      folds: 0,
       sessionId,
       waiting: /* @__PURE__ */ new Set(),
       taken: /* @__PURE__ */ new Set(),
@@ -26076,11 +26937,14 @@ var Bridge = class {
       const words4 = `${steer.from?.display_name ?? "The person"} adds: ${steer.text}`;
       void this.steered(turn, words4, steer.mode);
     });
-    const last = await ended;
+    const last = await ended2;
     await turn.chain;
     if (this.turns.get(sessionId) === turn) this.turns.delete(sessionId);
     if (last.outcome === "succeeded") await this.finish(turn);
     else await this.ended(turn, last);
+    await this.sendModel(turn.agentId);
+    await this.sendContext(turn.agentId);
+    await this.turnHeld(turn);
   }
   /** The words into the room's session: the one it had, or a new one when OpenCode no longer has it. */
   async give({ id: id2, who, agent, spaceId }, text2) {
@@ -26092,16 +26956,18 @@ var Bridge = class {
     }
     if (kept !== void 0) {
       try {
+        await this.modelled(kept, { who, agent });
         return { sessionId: kept, given: await this.prompted(kept, text2) };
       } catch (error62) {
         if (!(error62 instanceof OpenCodeError && error62.tag === "SessionNotFoundError")) throw error62;
         this.log(`${agent.config.name}'s session for ${spaceId} is gone from OpenCode: a new one`);
       }
     }
+    const pick2 = state2.models?.[who];
     const made = await opencode2.newSession({
       title: `Chips space ${spaceId}`,
       agent: agent.config.agent,
-      model: agent.model,
+      model: pick2 === void 0 ? agent.model : refOf(pick2),
       directory: await this.folderFor({ who, agent }),
       metadata: { chips_space: spaceId, chips_agent: who }
     });
@@ -26238,6 +27104,11 @@ var Bridge = class {
       return;
     }
     if (event.type === "session.forked") return;
+    if (event.type.startsWith("session.compaction.")) {
+      const going = this.turns.get(sessionId);
+      if (going === void 0) this.compactionHeard(sessionId, event);
+      else going.chain = going.chain.then(() => this.compactionHeard(sessionId, event));
+    }
     const own2 = this.turns.get(sessionId);
     if (own2 === void 0 && this.early.has(sessionId)) {
       this.early.get(sessionId)?.push(event);
@@ -26409,6 +27280,9 @@ var Bridge = class {
     const limit = await this.windowOf(model);
     if (limit === void 0) return;
     await turn.run.context({ usedTokens: prompt + written, limitTokens: limit, model }).catch(() => void 0);
+    const windows = this.options.state.windows ??= {};
+    windows[turn.who] = { ...windows[turn.who], used: prompt + written, window: limit, model, asOf: (/* @__PURE__ */ new Date()).toISOString(), session: turn.sessionId };
+    turn.peak = Math.max(turn.peak, prompt + written);
   }
   /** A model's context window, from OpenCode's catalogue, read once (and once more for each it lacked). */
   async windowOf(model) {
@@ -26442,7 +27316,12 @@ var Bridge = class {
     if (decision === void 0 || pending === void 0 || pending.answered) return;
     pending.answered = true;
     if (decision.allowed && toolCall !== void 0) turn.allowed.set(toolCall, approvalId);
-    await this.options.opencode.replyPermission(askingSession, requestId, decisionOf(decision), decision.allowed ? void 0 : decision.reason).catch((error62) => this.log(`OpenCode didn't take the answer: ${messageOf(error62)}`));
+    await this.options.opencode.replyPermission(
+      askingSession,
+      requestId,
+      decisionOf(decision, card.action.kind === "shell.exec"),
+      decision.allowed ? void 0 : decision.reason
+    ).catch((error62) => this.log(`OpenCode didn't take the answer: ${messageOf(error62)}`));
   }
   /** A permission answered in OpenCode's own apps: settled in Chips, once, so the card cools (ADR 0079). */
   async settled(turn, data) {
@@ -26580,9 +27459,24 @@ var Bridge = class {
     if (retryable) void this.sayHowItIs();
   }
 };
-function decisionOf(decision) {
+function settingsFor(bridge2) {
+  const active = () => {
+    const running = bridge2();
+    if (running === void 0) throw new Refuse("The harness is still starting.");
+    return running;
+  };
+  return {
+    models: (change) => active().modelChanged(change),
+    context: (edit) => active().contextEdited(edit),
+    contextWindows: {
+      compact: (ask2) => active().windowCompact(ask2),
+      change: (ask2) => active().windowChange(ask2)
+    }
+  };
+}
+function decisionOf(decision, command = false) {
   if (!decision.allowed) return "reject";
-  return decision.scope === "always" ? "always" : "once";
+  return decision.scope === "always" && !command ? "always" : "once";
 }
 function questionOf(field, title2) {
   const prompt = (field.description ?? field.title ?? title2).slice(0, 500);
@@ -26668,6 +27562,12 @@ function spoken(words4) {
   return end2 === -1 ? words4 : words4.slice(end2 + THOUGHT_ENDS.length);
 }
 var THOUGHT_ENDS = "</think>";
+function titleFrom(text2) {
+  const line = text2.trim().split("\n")[0] ?? "";
+  if (line.length <= 48) return line;
+  const cut2 = line.slice(0, 48);
+  return `${cut2.slice(0, Math.max(cut2.lastIndexOf(" "), 24))}\u2026`;
+}
 function forkName(original) {
   return `${original.trim().replace(/ · fork( \d+)?$/, "")} \xB7 fork`;
 }
@@ -26732,12 +27632,12 @@ function lastLine(said) {
 }
 
 // src/keep.ts
-import { homedir as homedir4 } from "node:os";
-import { basename as basename3, join as join6, resolve as resolve2 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename3, join as join7, resolve as resolve2 } 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) => resolve2(word.startsWith("~/") ? join6(homedir4(), word.slice(2)) : word);
+var whole = (word) => resolve2(word.startsWith("~/") ? join7(homedir5(), 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"];
@@ -26755,7 +27655,7 @@ function stopIfAsked(label2) {
   if (stopped2.state === "theirs") end(`${stopped2.path} wasn't written by this bridge: it was left as it is.`, 1);
   end(`Nothing called ${label2} was kept running here.`, 0);
 }
-function keepIfAsked(label2, url2, names, log2, before = () => void 0) {
+function keepIfAsked(label2, url2, names, log2, before2 = () => void 0) {
   if (!flags.includes("--keep")) return;
   const node2 = keptNode();
   const kept = keepRunning({
@@ -26765,7 +27665,7 @@ function keepIfAsked(label2, url2, names, log2, before = () => void 0) {
     environment: keepEnvironment(url2, process.env, names, node2)
   });
   if (kept.state === "kept") {
-    before();
+    before2();
     end(
       `Kept running as ${label2}: it starts at login, and again whenever it stops. What it says goes to ${kept.logFile}. \`${stopLine}\` stops it.`,
       0
@@ -26785,9 +27685,9 @@ function keepIfAsked(label2, url2, names, log2, before = () => void 0) {
 // src/server.ts
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { createServer } from "node:net";
-import { delimiter as delimiter2, join as join7 } from "node:path";
+import { delimiter as delimiter2, join as join8 } from "node:path";
 import { createInterface } from "node:readline";
 var ServerError = class extends Error {
   constructor(message, missing = false) {
@@ -26797,10 +27697,11 @@ var ServerError = class extends Error {
   missing;
   name = "ServerError";
 };
+var sleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 var onPath = (command, env) => command.includes("/") ? existsSync5(command) : (env["PATH"] ?? "").split(delimiter2).some((folder2) => {
   if (folder2 === "") return false;
   try {
-    accessSync2(join7(folder2, command), constants2.X_OK);
+    accessSync2(join8(folder2, command), constants2.X_OK);
     return true;
   } catch {
     return false;
@@ -26817,48 +27718,66 @@ async function freePort() {
   });
   return await tryPort(4096) ?? await tryPort(0) ?? 4096;
 }
-async function answers2(url2, password) {
+async function infoOf(url2, password) {
   try {
     const answer = await fetch(`${url2}/api/info`, {
       headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` },
       signal: AbortSignal.timeout(2e3)
     });
-    if (answer.ok) return "ok";
+    if (answer.ok) return await answer.json().catch(() => ({})) ?? {};
     return answer.status === 401 ? "refused" : "none";
   } catch {
     return "none";
   }
 }
+async function answers2(url2, password) {
+  const info = await infoOf(url2, password);
+  return typeof info === "string" ? info : "ok";
+}
 function keptIn(path) {
   if (!existsSync5(path)) return void 0;
   try {
-    const kept = JSON.parse(readFileSync5(path, "utf8"));
+    const kept = JSON.parse(readFileSync6(path, "utf8"));
     return typeof kept.port === "number" && typeof kept.password === "string" ? kept : void 0;
   } catch {
     return void 0;
   }
 }
+function alive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error62) {
+    return error62.code === "EPERM";
+  }
+}
+async function ended(pid, ms) {
+  for (const signal of ["SIGTERM", "SIGKILL"]) {
+    try {
+      process.kill(pid, signal);
+    } catch {
+      return;
+    }
+    for (const by = Date.now() + (signal === "SIGTERM" ? ms : 2e3); alive(pid) && Date.now() < by; ) await sleep(50);
+    if (!alive(pid)) return;
+  }
+}
 async function ownServer(options) {
   const env = options.env ?? process.env;
   const command = options.command ?? "opencode";
   const log2 = options.log ?? (() => void 0);
-  const path = join7(options.folder, "server.json");
+  const path = join8(options.folder, "server.json");
   let kept = keptIn(path);
+  let before2 = false;
   if (kept !== void 0) {
-    const url3 = `http://127.0.0.1:${kept.port}`;
-    const now = await answers2(url3, kept.password);
-    if (now === "ok") {
-      log2(`OpenCode's server from before is still answering at ${url3}`);
-      return { url: url3, password: kept.password, stop: () => void 0 };
-    }
+    const now = await answers2(`http://127.0.0.1:${kept.port}`, kept.password);
+    before2 = now === "ok";
     if (now === "refused") kept = { port: await freePort(), password: kept.password };
   }
-  if (!onPath(command, env)) {
+  if (!before2 && !onPath(command, env)) {
     throw new ServerError("OpenCode isn't installed on this machine: install it (opencode.ai), then run this again.", true);
   }
   kept ??= { port: await freePort(), password: randomBytes(24).toString("base64url") };
-  writeFileSync4(path, `${JSON.stringify(kept, null, 2)}
-`, { mode: 384 });
   const { port, password } = kept;
   const url2 = `http://127.0.0.1:${port}`;
   let child;
@@ -26866,8 +27785,11 @@ async function ownServer(options) {
   let answered = false;
   let failed;
   let wait2 = 2e3;
+  let again2;
   const said = [];
   const start = () => {
+    writeFileSync4(path, `${JSON.stringify({ port, password }, null, 2)}
+`, { mode: 384 });
     const started = spawn(command, ["serve", "--hostname", "127.0.0.1", "--port", String(port)], {
       cwd: options.cwd,
       env: { ...env, OPENCODE_PASSWORD: password },
@@ -26889,9 +27811,10 @@ async function ownServer(options) {
         return;
       }
       log2(`OpenCode's server stopped (${signal ?? `exit ${code}`}): starting it again in ${wait2 / 1e3} s`);
-      setTimeout(() => {
-        if (!stopping) start();
-      }, wait2).unref();
+      again2 = setTimeout(() => {
+        if (!stopping && child === void 0) start();
+      }, wait2);
+      again2.unref();
       wait2 = Math.min(wait2 * 2, 6e4);
     });
     started.on("error", (error62) => {
@@ -26900,33 +27823,76 @@ async function ownServer(options) {
     });
     child = started;
   };
-  start();
-  const by = Date.now() + (options.waitMs ?? 3e4);
-  while (await answers2(url2, password) !== "ok") {
-    if (failed !== void 0 || Date.now() > by) {
-      stopping = true;
-      child?.kill("SIGTERM");
-      const last = said.slice(-3).join(" ").trim();
-      throw new ServerError(`OpenCode's server didn't start at ${url2}${last === "" ? "" : `: ${last}`}`);
+  const up = async (anew) => {
+    stopping = false;
+    answered = false;
+    failed = void 0;
+    said.length = 0;
+    start();
+    const by = Date.now() + (options.waitMs ?? 3e4);
+    while (await answers2(url2, password) !== "ok") {
+      if (failed !== void 0 || Date.now() > by) {
+        stopping = true;
+        child?.kill("SIGTERM");
+        const last = said.slice(-3).join(" ").trim();
+        throw new ServerError(`OpenCode's server didn't start${anew ? " again" : ""} at ${url2}${last === "" ? "" : `: ${last}`}`);
+      }
+      await sleep(250);
+    }
+    answered = true;
+    wait2 = 2e3;
+  };
+  const down = async () => {
+    stopping = true;
+    clearTimeout(again2);
+    const stopMs = options.stopMs ?? 1e4;
+    const pid = child?.pid;
+    if (pid !== void 0) return ended(pid, stopMs);
+    const info = await infoOf(url2, password);
+    if (typeof info === "string") return;
+    if (typeof info["pid"] !== "number" || info["pid"] <= 0 || info["pid"] === process.pid) {
+      throw new ServerError(
+        `OpenCode's server at ${url2} was running before this bridge and doesn't say which process it is: stop it on this machine, then restart again.`
+      );
     }
-    await new Promise((resolve5) => setTimeout(resolve5, 250));
+    await ended(info["pid"], stopMs);
+  };
+  if (before2) log2(`OpenCode's server from before is still answering at ${url2}`);
+  else {
+    await up(false);
+    log2(`OpenCode's own server answering at ${url2}`);
   }
-  answered = true;
-  log2(`OpenCode's own server answering at ${url2}`);
+  let restarting;
+  const restart = async () => {
+    if (!onPath(command, env)) {
+      throw new ServerError("OpenCode isn't installed on this machine any more: install it (opencode.ai), then restart again.", true);
+    }
+    log2(`restarting OpenCode's server at ${url2}`);
+    await down();
+    await up(true);
+    log2(`OpenCode's server is answering again at ${url2}`);
+  };
   return {
     url: url2,
     password,
     stop: () => {
       stopping = true;
+      clearTimeout(again2);
       child?.kill("SIGTERM");
+    },
+    restart: () => {
+      restarting ??= restart().finally(() => {
+        restarting = void 0;
+      });
+      return restarting;
     }
   };
 }
 
 // src/setup.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join8, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join9, resolve as resolve3 } from "node:path";
 var SetupError = class extends Error {
   constructor(message, words4 = {}) {
     super(message);
@@ -26943,9 +27909,9 @@ var hostOf = (url2) => {
   }
 };
 var STILL_GOOD = "The link is still good: run the same command again once that's done.";
-var home = (path) => path.startsWith("~/") ? join8(homedir5(), path.slice(2)) : path;
+var home = (path) => path.startsWith("~/") ? join9(homedir6(), path.slice(2)) : path;
 function readConfig(path, env = process.env) {
-  const raw = existsSync6(path) ? JSON.parse(readFileSync6(path, "utf8")) : {};
+  const raw = existsSync6(path) ? JSON.parse(readFileSync7(path, "utf8")) : {};
   const passwordEnv = typeof raw["passwordEnv"] === "string" ? raw["passwordEnv"] : "OPENCODE_PASSWORD";
   const password = filledIn(env[passwordEnv]) ? env[passwordEnv] : void 0;
   const ownServer2 = password === void 0 && typeof raw["url"] !== "string";
@@ -27001,7 +27967,7 @@ async function checkOpenCode(config3, client) {
 }
 
 // src/main.ts
-var home2 = (path) => path.startsWith("~/") ? join9(homedir6(), path.slice(2)) : path;
+var home2 = (path) => path.startsWith("~/") ? join10(homedir7(), path.slice(2)) : path;
 var link = process.env["CHIPS_JOIN_LINK"] || void 0;
 var LABEL = "chat.chips.opencode";
 stopIfAsked(LABEL);
@@ -27021,13 +27987,13 @@ try {
 } catch (error62) {
   config2 = stop(error62);
 }
-var folder = dirname4(configPath);
+var folder = dirname5(configPath);
 mkdirSync5(folder, { recursive: true, mode: 448 });
-var statePath = join9(folder, "sessions.json");
+var statePath = join10(folder, "sessions.json");
 var server;
 if (link !== void 0) reportStep("checking", { detail: "Looking for OpenCode" });
 if (config2.ownServer) {
-  const cwd = config2.directory ?? dirname4(config2.folders);
+  const cwd = config2.directory ?? dirname5(config2.folders);
   mkdirSync5(cwd, { recursive: true });
   try {
     server = await ownServer({ folder, cwd, log });
@@ -27068,20 +28034,26 @@ var joined = await join3({
   url: process.env["CHIPS_URL"],
   name: config2.name,
   software: "chips-opencode 1.0.0",
-  wants: WANTS,
+  wants: wantsFor(server !== void 0),
   onCode: (code) => log(`Allow this harness in Chips: ${code}`)
 }).catch(refused2);
 keepIfAsked(LABEL, joined.url, [config2.passwordEnv], log, () => server?.stop());
-var state = existsSync7(statePath) ? JSON.parse(readFileSync7(statePath, "utf8")) : { sessions: {} };
+var state = existsSync7(statePath) ? JSON.parse(readFileSync8(statePath, "utf8")) : { sessions: {} };
+var bridge;
 var chips = await connect({
   url: joined.url,
   token: joined.token,
   client: { name: "chips-opencode", version: "1.0.0" },
-  store: fileStore(join9(folder, "chips-state.json"))
+  store: fileStore(join10(folder, "chips-state.json")),
+  // A person's Restart (Chips ADR 0094), heard only where the bridge runs OpenCode's server: one a
+  // person runs themselves isn't the bridge's to restart, so this connection doesn't say it hears them.
+  ...server === void 0 ? {} : { onRestart: () => bridge?.restart() },
+  // What a person changes of an agent from its page (Chips ADR 0241): its model and its files.
+  settings: settingsFor(() => bridge)
 });
 var git = await checkGit();
 if (!git.ok) log(`rooms' projects are off: ${git.why}`);
-var bridge = new Bridge({
+bridge = new Bridge({
   chips,
   opencode,
   projects: git.ok,
@@ -27091,7 +28063,8 @@ var bridge = new Bridge({
   saveState: (next) => writeFileSync5(statePath, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 }),
   log,
-  ...config2.directory === void 0 ? { folders: config2.folders } : {}
+  restartServer: server?.restart,
+  ...config2.directory === void 0 ? { folders: config2.folders } : { directory: config2.directory }
 });
 await bridge.start();
 log(`answering for ${config2.agents.map((agent) => agent.name).join(", ")} through OpenCode at ${address.url}`);