@chipschat/opencode 1.0.6 → 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,15 +26020,131 @@ 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;
   }
 }
@@ -25735,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 = [];
@@ -25770,6 +26213,15 @@ var Bridge = class {
   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;
@@ -25789,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();
@@ -25823,6 +26283,7 @@ var Bridge = class {
     try {
       await again2();
       this.why = void 0;
+      this.readsNamed = void 0;
       this.wake?.();
     } catch (error62) {
       const why = messageOf(error62).replace(/\s+/g, " ").trim();
@@ -25844,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;
   }
@@ -25915,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) {
@@ -25976,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, {
@@ -25986,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) {
@@ -25993,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 = {}) {
@@ -26104,6 +26907,10 @@ var Bridge = class {
       run: run2,
       speaker,
       agent,
+      who: room.who,
+      agentId: speakerId ?? agent.agentId,
+      peak: 0,
+      folds: 0,
       sessionId,
       waiting: /* @__PURE__ */ new Set(),
       taken: /* @__PURE__ */ new Set(),
@@ -26135,6 +26942,9 @@ var Bridge = class {
     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) {
@@ -26146,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 }
     });
@@ -26292,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);
@@ -26463,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) {
@@ -26639,6 +27459,21 @@ var Bridge = class {
     if (retryable) void this.sayHowItIs();
   }
 };
+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" && !command ? "always" : "once";
@@ -26727,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`;
 }
@@ -26791,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"];
@@ -26814,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({
@@ -26824,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
@@ -26844,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) {
@@ -26860,7 +27701,7 @@ 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;
@@ -26896,7 +27737,7 @@ async function answers2(url2, password) {
 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;
@@ -26925,15 +27766,15 @@ 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 before = false;
+  let before2 = false;
   if (kept !== void 0) {
     const now = await answers2(`http://127.0.0.1:${kept.port}`, kept.password);
-    before = now === "ok";
+    before2 = now === "ok";
     if (now === "refused") kept = { port: await freePort(), password: kept.password };
   }
-  if (!before && !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") };
@@ -27016,7 +27857,7 @@ async function ownServer(options) {
     }
     await ended(info["pid"], stopMs);
   };
-  if (before) log2(`OpenCode's server from before is still answering at ${url2}`);
+  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}`);
@@ -27049,9 +27890,9 @@ async function ownServer(options) {
 }
 
 // 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);
@@ -27068,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";
@@ -27126,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);
@@ -27146,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 });
@@ -27197,16 +28038,18 @@ var joined = await join3({
   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() }
+  ...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}`);
@@ -27221,7 +28064,7 @@ bridge = new Bridge({
 `, { mode: 384 }),
   log,
   restartServer: server?.restart,
-  ...config2.directory === void 0 ? { folders: config2.folders } : {}
+  ...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}`);