@chipschat/opencode 1.0.6 → 1.0.9

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 readFileSync9, 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;
   }
@@ -19943,8 +19943,9 @@ var policyRule = external_exports.object({
     external: external_exports.boolean().optional(),
     irreversible: external_exports.boolean().optional(),
     money_usd_over: external_exports.number().nonnegative().optional(),
-    risk: external_exports.array(riskClass).max(8).optional()
-  }).optional().describe("Extra conditions on the action's flags."),
+    risk: external_exports.array(riskClass).max(8).optional(),
+    starts_with: external_exports.array(external_exports.string().min(1).max(400)).min(1).max(8).optional().describe("For an action that carries a command (ADR 0239): the words a part of it starts with. A command goes ahead on such rules only when every part starts with one that allows it.")
+  }).optional().describe("Extra conditions on the action's flags, and for a command, how its parts start."),
   decision: external_exports.enum(["allow", "ask", "deny"]).describe("What to do when the rule matches."),
   approvers: external_exports.array(approverRef).max(16).optional().describe("Who may answer, when the decision is `ask`."),
   reason: external_exports.string().max(400).optional().describe("Shown to the harness, and recorded in the audit log."),
@@ -20463,9 +20464,17 @@ var roomIdle = external_exports.object({
 var roomNote = external_exports.object({
   members: external_exports.array(roomMember).max(500).describe("The room's people, then its agents, each by name, anybody removed left out."),
   notes: external_exports.record(external_exports.string().max(120), external_exports.string().max(64e3)).describe("The note for each who takes the turn (`for`), by their id: who is here, with handles, and that only those @-mentioned act. A harness puts it at the top of the turn."),
+  rules: external_exports.record(external_exports.string().max(120), external_exports.string().max(4e3)).optional().describe("How the space works, for each who takes the turn, by their id: the words its note ends with (ADR 0250), that everyone here reads what it writes and, beside other agents, what an @ does and when to answer NO_REPLY. They stay the same while the space's agents do, so a harness whose session keeps its earlier turns may say them once, and the note without them after."),
   working: external_exports.array(roomWork).max(500).optional().describe("The room's agents with a turn going as Chips sends this one (ADR 0104), the takers' own included. A turn nothing has been heard from for ten minutes is not counted."),
   idle: external_exports.array(roomIdle).max(500).optional().describe("The room's other agents that have had a turn here: how long since the last one ended (ADR 0104).")
 });
+function noteWithoutRules(room, taker) {
+  const note = room?.notes[taker];
+  const rules = room?.rules?.[taker];
+  if (note === void 0 || rules === void 0 || !note.endsWith(rules))
+    return note;
+  return note.slice(0, note.length - rules.length).trimEnd();
+}
 var MONTHS = [
   "January",
   "February",
@@ -20485,8 +20494,8 @@ var MONTHS = [
 var CONTEXT_CEILING = { lines: 200, chars: 32e3 };
 var CONTEXT_HEADING = "Said in this space since you last spoke:";
 var contextBudget = external_exports.object({
-  lines: external_exports.int().nonnegative().optional().describe("The most lines to be handed, 20 when absent. Chips hands over 200 at most, and none when this is 0."),
-  chars: external_exports.int().nonnegative().optional().describe("The most characters those lines may run to, as `Name: words` one per line, 4,000 when absent. Chips hands over 32,000 at most.")
+  lines: external_exports.int().nonnegative().optional().describe("The most lines to be handed, 40 when absent. Chips hands over 200 at most, and none when this is 0."),
+  chars: external_exports.int().nonnegative().optional().describe("The most characters those lines may run to, as `Name: words` one per line, 16,000 when absent. Chips hands over 32,000 at most.")
 }).describe("How much of the room a harness is handed with a message for it (ADR 0088). Its own to say: a budget promises nothing to anybody else.");
 var contextLine = external_exports.object({
   seq: external_exports.int().positive().describe("Where in the log it happened."),
@@ -20698,12 +20707,14 @@ var contextAnswer = {
     message: external_exports.string().min(1).max(300).optional().describe("What went wrong, for the person.")
   }).optional().describe("An edit not made. The copy beside it is the file as it is now.")
 };
+var readNote = external_exports.string().min(1).max(300).describe("When the agent reads these, in the harness's words: `Hermes reads these when a conversation starts.` Absent: at the start of every turn.");
 function uniqueNames(files) {
   return new Set(files.map((file3) => file3.name)).size === files.length;
 }
 var agentContextPut = external_exports.object({
   files: external_exports.array(contextFile).max(CONTEXT_FILES_SHOWN).refine(uniqueNames, { message: "Each file is named once." }).describe("The agent's files, in the order its page shows them: eight at most."),
   not_shown: external_exports.array(notShownFile).max(CONTEXT_NOT_SHOWN_MAX).optional(),
+  read_note: readNote.optional(),
   ...contextAnswer
 }).describe("`PUT /v1/agents/:id/context`: a harness's copy of one of its agents' files.");
 var harnessContextPut = external_exports.object({
@@ -20736,6 +20747,7 @@ var agentContextView = external_exports.object({
   harness_id: id("harness"),
   files: external_exports.array(contextFile),
   not_shown: external_exports.array(notShownFile),
+  read_note: readNote.optional(),
   read_at: isoTimestamp.describe("When the harness last sent its copy."),
   away: external_exports.boolean().describe("No socket of the harness hears edits now: read, but not saved.")
 }).describe("`GET /v1/agents/:id/context`, for the harness's owner.");
@@ -20863,7 +20875,7 @@ var messageNew = defineEvent({
   summary: "Someone said something, with any attachments as signed URLs the harness can fetch.",
   requiresRun: false,
   payload: deliveredMessage.extend({
-    context: roomContext.optional().describe("What was said in the room since this harness last spoke there, or since it joined when it has not, up to this message and without it (ADR 0088). From when the turn that said its last words began, so what was said while it worked is here, and its own words are not (ADR 0105). Worked out from the log, so a replay hands over the same lines. As many as the budget the harness gave in its `hello`: 20 lines and 4,000 characters when it gave none, and none when it asked for 0. When older lines were left out, the taker's room note says so."),
+    context: roomContext.optional().describe("What was said in the room since this harness last spoke there, or since it joined when it has not, up to this message and without it (ADR 0088). From when the turn that said its last words began, so what was said while it worked is here, and its own words are not (ADR 0105). Worked out from the log, so a replay hands over the same lines. As many as the budget the harness gave in its `hello`: 40 lines and 16,000 characters when it gave none, and none when it asked for 0. When older lines were left out, the taker's room note says so."),
     room: roomNote.optional().describe("Who is in the room, with the handle that reaches each, and a note for each who takes the turn saying so and what an @ does (ADR 0092). A harness puts `notes[<taker>]` at the top of that turn. Absent on a message in no room."),
     exchange: deliveredExchange.optional().describe("How the agents' talk in the room stands, once it is worth a word (ADR 0097): from eight messages between agents since a person last acted or an agent last made something new. A harness puts `note` at the top of the turn, as Chips's, ahead of the room's note. Absent below that, and worked out from the log, so a replay hands over the same facts."),
     handed: external_exports.literal(true).optional().describe("Chips held this message when it was said and hands it over now a person has acted (ADR 0097): the newest of an agent's held messages, once; or, with `lead`, hands it to the room's lead. Its seq and id are the hand-over's, its `message_id` the message's own."),
@@ -20913,6 +20925,7 @@ var approvalResolved = defineEvent({
     approval_id: id("approval"),
     decision: external_exports.enum(["approved", "edited", "denied", "expired"]).describe("`expired` means nobody answered and the fallback applied."),
     scope: external_exports.enum(["once", "session", "always"]).default("once").describe("How far the answer reaches. `always` becomes a policy rule."),
+    everywhere: external_exports.boolean().optional().describe("With `always`: the rule is the harness's in every space, not only this one (ADR 0239). An owner or an admin only."),
     updated_input: external_exports.unknown().optional().describe("The edited action input, when the decision is `edited`."),
     reason: external_exports.string().max(4e3).optional().describe("Why. The harness gets to read this."),
     resolved_by: external_exports.string().min(1).max(120).describe("The participant who answered, or `system` on expiry \u2014 a harness when it settles its own ask, answered in its own tools. Filled in by Chips from the credential that sent it; a value the sender writes is replaced."),
@@ -21177,6 +21190,10 @@ function namesInWords(names) {
   return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
 }
 function renderProjectNote(facts, options) {
+  return `${renderProjectFacts(facts)}
+${renderProjectAsks(facts, options)}`;
+}
+function renderProjectFacts(facts) {
   const files = `${facts.files} file${facts.files === 1 ? "" : "s"}`;
   const lines2 = [
     `The space's project is a git repository. Your copy is ${facts.folder} (${files}), ${facts.trouble === void 0 ? "brought up to date just now" : "not brought up to date"}.`
@@ -21194,9 +21211,9 @@ function renderProjectNote(facts, options) {
   for (const key of facts.keys) {
     lines2.push(`${key.path} holds what looks like ${key.what}, so your last change wasn't sent: take it out and read it from outside the project.`);
   }
-  return [...lines2, ...asks(facts, options)].join("\n");
+  return lines2.join("\n");
 }
-function asks(facts, options) {
+function renderProjectAsks(facts, options) {
   const lines2 = [
     "Work on the project in that folder and leave git to Chips: when your turn ends, what you changed is committed under your name and sent to everyone here. Keep scratch work outside it.",
     // Sent with the answer too, a project's file became a room file of its own, with versions of
@@ -21217,7 +21234,7 @@ function asks(facts, options) {
   if (facts.pages === true) {
     lines2.push("A page opens in Chips as one document: name every file it needs in its tags and imports (<link>, <script src>, <img src>, import), since it can't fetch files while it runs.");
   }
-  return lines2;
+  return lines2.join("\n");
 }
 
 // node_modules/@chipschat/protocol/dist/src/events/harness-to-chips.js
@@ -21869,7 +21886,7 @@ var membershipRemoved = defineEvent({
   payload: external_exports.object({
     participant_id: external_exports.string().min(1).max(120).describe("Who left."),
     removed_by: external_exports.string().min(1).max(120).optional().describe("Who removed them, if not themselves."),
-    reason: external_exports.enum([...RELEASE_REASONS, "person_removed"]).optional().describe("For an agent (ADR 0087): why it left, as `agent.released` says. For a person, `person_removed`: they were removed from the workspace (ADR 0160). Written by Chips; absent, a person took them out or they left."),
+    reason: external_exports.enum([...RELEASE_REASONS, "person_removed", "person_left"]).optional().describe("For an agent (ADR 0087): why it left, as `agent.released` says. For a person, `person_removed`: they were removed from the workspace (ADR 0160); `person_left`: they deleted their account and left it (ADR 0243). Written by Chips; absent, a person took them out or they left the room."),
     moved_to: id("space").optional().describe("For an agent moved away: the room it went to, so this room can say so.")
   })
 });
@@ -22178,14 +22195,14 @@ var personRemoved = defineEvent({
   type: "person.removed",
   direction: "workspace",
   sender: "chips",
-  summary: "A person was removed from the workspace: signed out everywhere, out of every room, and the harnesses they owned handed to whoever removed them. What they said stays, under their name.",
+  summary: "A person was removed from the workspace, or deleted their account: signed out everywhere, out of every room, and the harnesses they owned handed on. What they said stays, under their name.",
   requiresRun: false,
   payload: external_exports.object({
     participant_id: id("person").describe("Who was removed."),
     display_name: external_exports.string().min(1).max(120).describe("What they were called when they were removed, so the audit needs no lookup."),
-    removed_by: id("person").describe("The owner or admin who removed them."),
+    removed_by: id("person").describe("The owner or admin who removed them, or they themselves when they deleted their account (ADR 0243)."),
     spaces: external_exports.array(id("space")).max(1e3).optional().describe("The rooms they were taken out of, each with its own `membership.removed`."),
-    harnesses: external_exports.array(id("harness")).max(1e3).optional().describe("The harnesses they owned, handed to `removed_by` by `harness.transferred`.")
+    harnesses: external_exports.array(id("harness")).max(1e3).optional().describe("The harnesses they owned, each handed on by `harness.transferred`: to `removed_by`, or, for an account deleted, to an owner.")
   })
 });
 var joinWho = {
@@ -22401,6 +22418,89 @@ var EVENT_TYPES = EVENTS.map((event) => event.type);
 var byType = new Map(EVENTS.map((event) => [event.type, event]));
 var schemas = new Map(EVENTS.map((event) => [event.type, eventSchema(event)]));
 
+// node_modules/@chipschat/protocol/dist/src/names.js
+var LOOK_LIKE = {
+  A: "\u0410\u0391",
+  // Cyrillic А, Greek Α
+  B: "\u0412\u0392",
+  // Cyrillic В, Greek Β
+  C: "\u0421",
+  // Cyrillic С
+  E: "\u0415\u0395",
+  // Cyrillic Е, Greek Ε
+  H: "\u041D\u0397",
+  // Cyrillic Н, Greek Η
+  I: "\u0406\u04C0\u0399",
+  // Cyrillic І and Ӏ, Greek Ι
+  J: "\u0408",
+  // Cyrillic Ј
+  K: "\u041A\u039A",
+  // Cyrillic К, Greek Κ
+  M: "\u041C\u039C",
+  // Cyrillic М, Greek Μ
+  N: "\u039D",
+  // Greek Ν
+  O: "\u041E\u039F",
+  // Cyrillic О, Greek Ο
+  P: "\u0420\u03A1",
+  // Cyrillic Р, Greek Ρ
+  Q: "\u051A",
+  // Cyrillic Ԛ
+  S: "\u0405",
+  // Cyrillic Ѕ
+  T: "\u0422\u03A4",
+  // Cyrillic Т, Greek Τ
+  W: "\u051C",
+  // Cyrillic Ԝ
+  X: "\u0425\u03A7",
+  // Cyrillic Х, Greek Χ
+  Y: "\u0423\u04AE\u03A5",
+  // Cyrillic У and Ү, Greek Υ
+  Z: "\u0396",
+  // Greek Ζ
+  a: "\u0430\u03B1",
+  // Cyrillic а, Greek α
+  c: "\u0441",
+  // Cyrillic с
+  d: "\u0501",
+  // Cyrillic ԁ
+  e: "\u0435",
+  // Cyrillic е
+  h: "\u04BB",
+  // Cyrillic һ
+  i: "\u0456\u03B9\u0131",
+  // Cyrillic і, Greek ι, Latin dotless ı
+  j: "\u0458",
+  // Cyrillic ј
+  k: "\u03BA",
+  // Greek κ
+  l: "\u04CF",
+  // Cyrillic ӏ
+  o: "\u043E\u03BF",
+  // Cyrillic о, Greek ο
+  p: "\u0440\u03C1",
+  // Cyrillic р, Greek ρ
+  q: "\u051B",
+  // Cyrillic ԛ
+  s: "\u0455",
+  // Cyrillic ѕ
+  u: "\u03C5",
+  // Greek υ
+  v: "\u03BD",
+  // Greek ν
+  w: "\u051D",
+  // Cyrillic ԝ
+  x: "\u0445\u03C7",
+  // Cyrillic х, Greek χ
+  y: "\u0443\u04AF"
+  // Cyrillic у and ү
+};
+var LATIN_OF = new Map(Object.entries(LOOK_LIKE).flatMap(([latin, others]) => [...others].map((other) => [other, latin])));
+var HIDDEN = "\\p{Cc}\\p{Cf}\\u034f\\u115f\\u1160\\u3164\\uffa0\\u2800";
+var UNSEEN = new RegExp(`[${HIDDEN}\\ufe00-\\ufe0f\\u{e0100}-\\u{e01ef}]`, "gu");
+var HIDDEN_ONE = new RegExp(`[${HIDDEN}]`, "u");
+var ALPHABETS = [new RegExp("\\p{Script=Latin}", "u"), new RegExp("\\p{Script=Cyrillic}", "u"), new RegExp("\\p{Script=Greek}", "u")];
+
 // node_modules/@chipschat/protocol/dist/src/first-names.js
 var AGENT_FIRST_NAMES = [
   "Abel Aldo Amir Amos Anders Ansel Anton Ari Arlo Arne Aron Arvid Asher Avi Axel Aziz",
@@ -22448,7 +22548,7 @@ var clientHelloFrame = external_exports.object({
   })).max(64).optional().describe("Not read by Chips: a connection is its token's, and the server's `hello` names the token's harness and its agents (ADR 0087). Absent for a person's client."),
   since: external_exports.int().nonnegative().optional().describe("Not read by Chips: a stream resumes from `subscribe`'s `since`."),
   accepts: external_exports.array(external_exports.string().min(1).max(40)).max(32).optional().describe("Server frames beyond the base set this client understands, by the names in `SERVER_EXTENSIONS`. A name the server does not know is ignored rather than refused, so a client may name a frame a newer server sends and still be answered by an older one (ADR 0211, Phase 3). A client that says `events` is sent its replay in pages rather than one frame per event; one that says `presence` is sent an agent's state as it changes (ADR 0083); a harness's socket that says `restart` is sent `restart` when a person asks it to restart (ADR 0094); an owner's or admin's that says `join` is sent each join request as it changes (ADR 0122); a harness's that says `context` is sent `context.edit` when a person changes one of its context files (ADR 0134); a harness's that says `models` is sent `model.change` when a person changes an agent's model or effort (ADR 0140); a harness's that says `heartbeats` is sent `heartbeat.change` when a person switches an agent's heartbeat or changes how often it beats (ADR 0143); a harness's that says `context_windows` is sent `context_window.compact` and `context_window.change` when a person asks an agent to compact now or changes the limit it compacts itself at (ADR 0146); a person's that says `folders` is sent `folder.open` when they ask, from another of their devices, for a room's folder to be opened in Finder (ADR 0225), and `folder.run` when they ask for its project to be run or stopped there (ADR 0226); a person's that says `folder_runs` is sent `folder.run_state` when their Mac says how a run of theirs stands (ADR 0226); one that says nothing is sent what it was always sent, since an unknown frame is dropped in silence."),
-  context: contextBudget.optional().describe("How much of a room a harness is handed with each message for it (ADR 0088): 20 lines and 4,000 characters when absent, 200 and 32,000 at most. For this connection. A person's client is handed none.")
+  context: contextBudget.optional().describe("How much of a room a harness is handed with each message for it (ADR 0088): 40 lines and 16,000 characters when absent, 200 and 32,000 at most. For this connection. A person's client is handed none.")
 }).describe("The first frame a client sends.");
 var subscribeFrame = external_exports.object({
   frame: external_exports.literal("subscribe"),
@@ -25010,8 +25110,19 @@ async function redeem(url2, secret, options, send, machine) {
     throw await refused(answered);
   return await answered.json();
 }
+function reaching(send, url2) {
+  return async (input2, init) => {
+    try {
+      return await send(input2, init);
+    } catch (error62) {
+      if (error62 instanceof Error && error62.name === "AbortError")
+        throw error62;
+      throw new JoinError("unreachable", `Can't reach Chips at ${url2} from this computer. It has to be on the same network as Chips, on its tailnet, or Chips has to be at an address this computer can reach.`);
+    }
+  };
+}
 function askOrRedeem(server2, options) {
-  const send = options.fetch ?? fetch;
+  const send = reaching(options.fetch ?? fetch, server2.url);
   const machine = options.machine ?? hostname3();
   return server2.secret === void 0 ? ask(server2.url, options, send, machine) : redeem(server2.url, server2.secret, options, send, machine);
 }
@@ -25177,14 +25288,31 @@ async function sendAnswer(answer, options) {
 }
 
 // node_modules/@chipschat/harness/dist/prompt.js
+function takerOf(message, options) {
+  return options.taker ?? (message.for?.length === 1 ? message.for[0] : void 0);
+}
+function othersBeside(message, taker) {
+  return (message.room?.members ?? []).some((member) => member.kind === "agent" && member.participant_id !== taker);
+}
+function rulesFor(message, options = {}) {
+  const taker = takerOf(message, options);
+  const { project } = options;
+  const rules = message.room?.rules ?? {};
+  return [
+    taker === void 0 ? void 0 : rules[taker],
+    project === void 0 ? void 0 : renderProjectAsks(project, { othersInRoom: othersBeside(message, taker) }),
+    options.sendsFiles === true ? sendingFiles({ project: project !== void 0 }) : void 0
+  ].filter((part) => part !== void 0 && part !== "").join("\n\n");
+}
 function promptFor(message, options = {}) {
-  const taker = options.taker ?? (message.for?.length === 1 ? message.for[0] : void 0);
+  const taker = takerOf(message, options);
+  const held = options.rulesHeld === true;
   const notes = message.room?.notes ?? {};
-  const note = taker === void 0 ? void 0 : notes[taker];
+  const note = taker === void 0 ? void 0 : held ? noteWithoutRules(message.room, taker) : notes[taker];
   const who = options.sayWho === false ? "" : `${withRole(message.from.display_name, message.from)}: `;
   const files = (message.attachments ?? []).map(renderAttachment);
   const words4 = [`${who}${message.text}`, ...files].join("\n");
-  const sending = options.sendsFiles === true ? sendingFiles({ project: options.project !== void 0 }) : void 0;
+  const sending = options.sendsFiles === true && !held ? sendingFiles({ project: options.project !== void 0 }) : void 0;
   const replying = renderReplyingTo(message.replying_to, {
     sender: {
       id: message.from.participant_id,
@@ -25196,8 +25324,7 @@ function promptFor(message, options = {}) {
     at: message.ts,
     zone: options.zone
   });
-  const others = (message.room?.members ?? []).some((member) => member.kind === "agent" && member.participant_id !== taker);
-  const project = options.project === void 0 ? void 0 : renderProjectNote(options.project, { othersInRoom: others });
+  const project = options.project === void 0 ? void 0 : held ? renderProjectFacts(options.project) : renderProjectNote(options.project, { othersInRoom: othersBeside(message, taker) });
   return [
     message.exchange?.note,
     note,
@@ -25209,6 +25336,24 @@ function promptFor(message, options = {}) {
   ].filter((part) => part !== void 0 && part !== "").join("\n\n");
 }
 
+// node_modules/@chipschat/harness/dist/rules.js
+var SessionRules = class {
+  held = /* @__PURE__ */ new Map();
+  /** Whether `session` holds these rules: told them word for word, or there are none to hold. */
+  holds(session, rules) {
+    return rules === "" || this.held.get(session) === rules;
+  }
+  /** That `session` was told these rules: its turn that said them was given to it. */
+  told(session, rules) {
+    if (rules !== "")
+      this.held.set(session, rules);
+  }
+  /** That `session` no longer holds what it was told: it compacted, or it is gone. */
+  forget(session) {
+    this.held.delete(session);
+  }
+};
+
 // node_modules/@chipschat/harness/dist/service.js
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { accessSync, chmodSync as chmodSync2, constants, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -25384,7 +25529,10 @@ function nodeOnPath(env = process.env) {
 }
 var pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 var LOAD_TRIES = 40;
-var runOf = (options) => options.run ?? ((command) => void execFileSync2(command[0], command.slice(1), { stdio: "ignore" }));
+var runOf = (options) => options.run ?? ((command) => execFileSync2(command[0], command.slice(1), {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "ignore"]
+}));
 var ours = (path) => !existsSync3(path) || readFileSync3(path, "utf8").includes(MARK);
 function runOne(command, run2, retryMs) {
   const tries = command[0] === "launchctl" && command[1] === "bootstrap" ? LOAD_TRIES : 1;
@@ -25407,6 +25555,24 @@ function runAll(commands, options) {
     runOne(command, run2, options.retryMs ?? 250);
 }
 var uidOf = (options) => options.uid ?? process.getuid?.() ?? 0;
+function lingers(options) {
+  const run2 = runOf(options);
+  const uid = String(uidOf(options));
+  try {
+    const on = run2(["loginctl", "show-user", uid, "--property=Linger", "--value"]);
+    if (typeof on === "string" && on.trim() === "yes")
+      return true;
+  } catch {
+  }
+  try {
+    run2(["loginctl", "enable-linger", uid]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var sayOf = (options) => options.say ?? ((line) => void process.stderr.write(`${line}
+`));
 function keepRunning(spec, options = {}) {
   if (machineOf(options.machine).env["CHIPS_KEEP"] === "off")
     return { state: "off" };
@@ -25421,6 +25587,9 @@ function keepRunning(spec, options = {}) {
   writeFileSync2(file3.path, file3.contents, { mode: 384 });
   chmodSync2(file3.path, 384);
   runAll(startCommands(file3.kind, spec.label, file3.path, uidOf(options)), options);
+  if (file3.kind === "systemd" && !lingers(options)) {
+    sayOf(options)("It stops when you log out. To keep it running on a machine nobody logs in to, run this once: sudo loginctl enable-linger $USER");
+  }
   return { state: "kept", path: file3.path, logFile: file3.logFile };
 }
 function stopKeeping(label2, options = {}) {
@@ -25467,7 +25636,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 +25939,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 +26044,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 +26100,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 +26139,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 +26155,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 +26189,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,12 +26344,17 @@ 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 = [];
   rooms = /* @__PURE__ */ new Map();
   /** The turn going in each OpenCode session. */
   turns = /* @__PURE__ */ new Map();
+  /** The room's rules each session holds (Chips ADR 0250): said once, and again after it compacts. */
+  rules = new SessionRules();
   /**
    * What a session said while it was being given a turn's words, before the turn was known: OpenCode
    * may say it took them before it answers that it has them. Heard by the turn once it is.
@@ -25770,6 +26384,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 +26412,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 +26454,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 +26476,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 +26547,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 +26649,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 +26661,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 +26669,305 @@ 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) {
+    if (event.type === "session.compaction.started") this.rules.forget(sessionId);
+    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 = {}) {
@@ -26082,16 +27057,18 @@ var Bridge = class {
     const speaker = speakerId === void 0 ? this.options.chips : this.options.chips.as(speakerId);
     const run2 = await speaker.runs.start({ spaceId, goal: goal ?? goalOf(message, agent.config.name) });
     const readied = await this.projectFor(room, speakerId ?? agent.agentId);
-    const text2 = promptFor(message, {
+    const asked = {
       ...speakerId === void 0 ? {} : { taker: speakerId },
       sayWho: saysWho !== true,
       sendsFiles: true,
       project: readied?.facts
-    });
+    };
+    const rules = rulesFor(message, asked);
+    const said = (session) => promptFor(message, { ...asked, rulesHeld: this.rules.holds(session, rules) });
     let sessionId;
     let given;
     try {
-      ({ sessionId, given } = await this.give(room, text2));
+      ({ sessionId, given } = await this.give(room, said, rules));
     } catch (error62) {
       await this.failed(run2, `${agent.config.name} couldn't reach OpenCode: ${messageOf(error62)}`, true);
       return;
@@ -26104,6 +27081,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,9 +27116,12 @@ 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) {
+  async give({ id: id2, who, agent, spaceId }, said, rules) {
     const { opencode: opencode2, state: state2, saveState } = this.options;
     let kept = state2.sessions[id2];
     if (kept === void 0 && this.copying.size > 0) {
@@ -26146,22 +27130,24 @@ var Bridge = class {
     }
     if (kept !== void 0) {
       try {
-        return { sessionId: kept, given: await this.prompted(kept, text2) };
+        await this.modelled(kept, { who, agent });
+        return { sessionId: kept, given: await this.prompted(kept, said(kept), rules) };
       } 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 }
     });
     state2.sessions[id2] = made;
     saveState(state2);
-    return { sessionId: made, given: await this.prompted(made, text2) };
+    return { sessionId: made, given: await this.prompted(made, said(made), rules) };
   }
   /**
    * The folder an agent's new sessions work in, its own: made the first time, named after it, and
@@ -26231,12 +27217,18 @@ var Bridge = class {
     return known.find((each) => each.agentId === who)?.name ?? "agent";
   }
   /** A turn's first words into a session, what it says meanwhile held for the turn. */
-  async prompted(sessionId, text2) {
+  /**
+   * A turn's words given to a session, which is told the room's rules they carry as they are
+   * given, so a compaction heard during the turn forgets them (Chips ADR 0250).
+   */
+  async prompted(sessionId, text2, rules) {
     this.early.set(sessionId, []);
+    this.rules.told(sessionId, rules);
     try {
       return await this.options.opencode.prompt(sessionId, text2);
     } catch (error62) {
       this.early.delete(sessionId);
+      this.rules.forget(sessionId);
       throw error62;
     }
   }
@@ -26292,6 +27284,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 +27460,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 +27639,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 +27742,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 +27812,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 +27835,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 +27845,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 +27865,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 +27881,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 +27917,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 +27946,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 +28037,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 +28070,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 +28089,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";
@@ -27125,8 +28146,12 @@ async function checkOpenCode(config3, client) {
   }
 }
 
+// src/version.ts
+import { readFileSync as readFileSync8 } from "node:fs";
+var VERSION = JSON.parse(readFileSync8(new URL("../package.json", import.meta.url), "utf8")).version;
+
 // 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 +28171,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 });
@@ -27192,21 +28217,23 @@ var joined = await join3({
   link,
   url: process.env["CHIPS_URL"],
   name: config2.name,
-  software: "chips-opencode 1.0.0",
+  software: `chips-opencode ${VERSION}`,
   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(readFileSync9(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")),
+  client: { name: "chips-opencode", version: VERSION },
+  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 +28248,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}`);