@kubitnodes/stellaris 0.4.1 → 0.4.2

package/dist/cli/index.js

@@ -1040,6 +1040,12 @@ import { z as z7 } from "zod";
 import { z as z6 } from "zod";
 var IMAGE_LIMIT_BYTES = 8 * 1024 * 1024;
 var ImageTypeSchema = z6.enum(["png", "jpeg", "gif", "webp"]);
+var IMAGE_KIND_NAMES = {
+  png: "PNG",
+  jpeg: "JPEG",
+  gif: "GIF",
+  webp: "WebP"
+};
 function startsWith(bytes, prefix, at = 0) {
   for (let index = 0; index < prefix.length; index += 1) {
     if (bytes[at + index] !== prefix[index]) {
@@ -1461,7 +1467,11 @@ var RunnerHelloSchema = z9.object({
   gitIdentityMissing: z9.array(GitIdentityPartSchema).optional(),
   /** Turns the runner runs at once, or null for no limit. */
   slots: z9.number().int().positive().nullable(),
-  /** Turns the runner is still running, when it registers again; the server fails the rest of its turns. */
+  /**
+   * Turns the runner is still running, when it registers again: the server fails the rest of its
+   * turns, and has any of these it has ended stopped once the stream opens, when the runner lists
+   * a CLI it can stop.
+   */
   turns: z9.array(UlidSchema).default([])
 });
 var RunnerWelcomeSchema = z9.object({ name: NameSchema, version: z9.string() });
@@ -1616,9 +1626,9 @@ var TurnOutcomeSchema = z9.object({
    */
   resumeFailed: ResumeFailureSchema.optional(),
   /**
-   * Set when the model service turned the turn away for now, as when it was overloaded or failed
-   * on its side, which the scheduler answers by sending the same wake again within minutes. A
-   * runner from before never sends it.
+   * Set when the turn failed for now: the model service turned it away or cut it off, or the runner
+   * could not reach the board before the CLI started. The scheduler answers it by sending the same
+   * wake again within minutes. A runner from before never sends it.
    */
   transient: z9.boolean().optional(),
   /** The model the CLI reported, when it reported one. */
@@ -2009,13 +2019,18 @@ var TurnRecordSchema = z10.object({
   stoppedBy: NameSchema.optional(),
   /** Why the CLI could not resume the turn's session, for a turn that failed so. */
   resumeFailed: ResumeFailureSchema.optional(),
-  /** Whether the model service turned the turn away for now: overloaded, or failing on its side. */
+  /**
+   * Whether the turn failed for now, which the same wake may get past in a minute: the model service
+   * turned it away or cut it off, the runner could not reach the board before the CLI started, or
+   * the job never reached the runner.
+   */
   transient: z10.boolean().optional(),
   /** How many turns in a row, this one included, could not resume the session for a `retry`. */
   resumeRetries: z10.number().int().positive().optional(),
   /**
    * Whether the server dropped the conversation's session after this turn, which the next starts
-   * anew: one its CLI could not resume, or a society role's home after a reflection completed.
+   * anew: one its CLI could not resume, or a society role's or a project member's home after a
+   * reflection completed.
    */
   sessionDropped: z10.boolean().optional(),
   /** The crons whose fire started the turn, which record how it ended. */
@@ -2260,6 +2275,11 @@ var ServerConfigSchema = z13.object({
   dataDir: z13.string().min(1),
   host: z13.string().min(1),
   port: z13.number().int().positive().max(65535),
+  /**
+   * A second port, on the same host, that serves Prometheus's counters at `/metrics` and nothing
+   * else, or null for none: the main port's `/metrics` is the interface's page.
+   */
+  metricsPort: z13.number().int().positive().max(65535).nullable(),
   /**
    * An address every runner's agents reach this server at, for example https://board.example, or
    * null for each runner to use the address it reaches the server at itself.
@@ -2300,7 +2320,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.4.1";
+var STELLARIS_VERSION = "0.4.2";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2992,6 +3012,451 @@ function filesOf(lines, status) {
   return [...files.values()];
 }
 
+// packages/shared/dist/image-metadata.js
+function withoutMetadata(bytes) {
+  switch (imageTypeOf(bytes)) {
+    case "jpeg":
+      return jpegWithoutMetadata(bytes);
+    case "png":
+      return pngWithoutMetadata(bytes);
+    case "gif":
+      return gifWithoutMetadata(bytes);
+    case "webp":
+      return webpWithoutMetadata(bytes);
+    default:
+      return null;
+  }
+}
+function exifOrientation(block) {
+  const tiff = startsWith2(block, EXIF_HEADER) ? block.subarray(EXIF_HEADER.length) : block;
+  let little;
+  if (tiff[0] === 73 && tiff[1] === 73) {
+    little = true;
+  } else if (tiff[0] === 77 && tiff[1] === 77) {
+    little = false;
+  } else {
+    return 1;
+  }
+  const number = (offset, size) => offset >= 0 && size <= tiff.length && offset <= tiff.length - size ? numberAt(tiff, offset, size, little) : null;
+  const directory = number(4, 4);
+  const count = directory === null ? null : number(directory, 2);
+  if (number(2, 2) !== 42 || directory === null || count === null) {
+    return 1;
+  }
+  for (let entry = directory + 2; entry < directory + 2 + count * 12; entry += 12) {
+    const tag = number(entry, 2);
+    if (tag === null) {
+      return 1;
+    }
+    if (tag === 274) {
+      const value = number(entry + 8, 2);
+      if (number(entry + 2, 2) !== 3 || number(entry + 4, 4) !== 1 || value === null || value < 1 || value > 8) {
+        return 1;
+      }
+      return value;
+    }
+  }
+  return 1;
+}
+function orientationOnly(orientation) {
+  const block = new Uint8Array([
+    77,
+    77,
+    0,
+    42,
+    0,
+    0,
+    0,
+    8,
+    0,
+    1,
+    1,
+    18,
+    0,
+    3,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+  ]);
+  block[19] = orientation;
+  return block;
+}
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc = (crcTable()[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var crcEntries;
+function crcTable() {
+  if (crcEntries === void 0) {
+    crcEntries = new Uint32Array(256);
+    for (let index = 0; index < 256; index += 1) {
+      let crc = index;
+      for (let bit = 0; bit < 8; bit += 1) {
+        crc = crc & 1 ? 3988292384 ^ crc >>> 1 : crc >>> 1;
+      }
+      crcEntries[index] = crc >>> 0;
+    }
+  }
+  return crcEntries;
+}
+var ascii2 = (text) => new TextEncoder().encode(text);
+var EXIF_HEADER = Uint8Array.of(69, 120, 105, 102, 0, 0);
+function startsWith2(bytes, prefix, at = 0) {
+  if (bytes.length - at < prefix.length) {
+    return false;
+  }
+  for (let index = 0; index < prefix.length; index += 1) {
+    if (bytes[at + index] !== prefix[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function typeAt(bytes, at) {
+  return String.fromCharCode(bytes[at] ?? 0, bytes[at + 1] ?? 0, bytes[at + 2] ?? 0, bytes[at + 3] ?? 0);
+}
+function numberAt(bytes, at, size, little = false) {
+  let value = 0;
+  for (let index = 0; index < size; index += 1) {
+    value = value * 256 + (bytes[at + (little ? size - 1 - index : index)] ?? 0);
+  }
+  return value;
+}
+function bigEndian(value, size) {
+  return Array.from({ length: size }, (_, index) => value >>> (size - 1 - index) * 8 & 255);
+}
+function littleEndian(value, size) {
+  return Array.from({ length: size }, (_, index) => value >>> index * 8 & 255);
+}
+var Kept = class {
+  buffer;
+  length = 0;
+  constructor(capacity) {
+    this.buffer = new Uint8Array(Math.max(capacity, 64));
+  }
+  add(piece) {
+    if (this.length + piece.length > this.buffer.length) {
+      const grown = new Uint8Array(Math.max(this.buffer.length * 2, this.length + piece.length));
+      grown.set(this.buffer.subarray(0, this.length));
+      this.buffer = grown;
+    }
+    this.buffer.set(piece, this.length);
+    this.length += piece.length;
+  }
+  /** Writes `piece` over what was kept from `at` on, as a size once what it measures is kept. */
+  set(at, piece) {
+    this.buffer.set(piece, at);
+  }
+  get bytes() {
+    return this.buffer.subarray(0, this.length);
+  }
+};
+function jpegWithoutMetadata(bytes) {
+  if (bytes[0] !== 255 || bytes[1] !== 216) {
+    return null;
+  }
+  const kept = new Kept(bytes.length);
+  kept.add([255, 216]);
+  let at = 2;
+  let orientationKept = false;
+  for (; ; ) {
+    if (at + 1 >= bytes.length || bytes[at] !== 255) {
+      return null;
+    }
+    const marker = bytes[at + 1] ?? 0;
+    if (marker === 255) {
+      at += 1;
+      continue;
+    }
+    if (marker === 0 || marker >= 2 && marker <= 191 || marker === 216 || marker === 217) {
+      return null;
+    }
+    if (marker === 1 || marker >= 208 && marker <= 215) {
+      kept.add([255, marker]);
+      at += 2;
+      continue;
+    }
+    if (at + 4 > bytes.length) {
+      return null;
+    }
+    const length = numberAt(bytes, at + 2, 2);
+    const end = at + 2 + length;
+    if (length < 2 || end > bytes.length) {
+      return null;
+    }
+    const payload = bytes.subarray(at + 4, end);
+    if (marker === 224) {
+      if (startsWith2(payload, JFIF) && payload.length >= 14) {
+        kept.add([255, 224, 0, 16]);
+        kept.add(payload.subarray(0, 12));
+        kept.add([0, 0]);
+      }
+    } else if (marker === 225) {
+      if (startsWith2(payload, EXIF_HEADER) && !orientationKept) {
+        orientationKept = true;
+        const orientation = exifOrientation(payload.subarray(EXIF_HEADER.length));
+        if (orientation !== 1) {
+          const exif = orientationOnly(orientation);
+          kept.add([255, 225, ...bigEndian(EXIF_HEADER.length + exif.length + 2, 2)]);
+          kept.add(EXIF_HEADER);
+          kept.add(exif);
+        }
+      }
+    } else if (marker === 226 && startsWith2(payload, ICC_PROFILE) || marker === 238 && startsWith2(payload, ADOBE) || // A frame, its tables, a scan, and their kin, JPEG-LS's frame and parameters among them.
+    marker >= 192 && marker <= 207 && marker !== 200 || marker >= 218 && marker <= 223 || marker === 247 || marker === 248) {
+      kept.add(bytes.subarray(at, end));
+    }
+    at = end;
+    if (marker !== 218) {
+      continue;
+    }
+    const scan = at;
+    for (; ; ) {
+      const next = bytes.indexOf(255, at);
+      if (next === -1 || next + 1 >= bytes.length) {
+        return null;
+      }
+      at = next;
+      const after = bytes[at + 1] ?? 0;
+      if (after !== 0 && after !== 255 && !(after >= 208 && after <= 215)) {
+        break;
+      }
+      at += 1;
+    }
+    kept.add(bytes.subarray(scan, at));
+    if (bytes[at + 1] === 217) {
+      kept.add([255, 217]);
+      return kept.bytes;
+    }
+  }
+}
+var JFIF = Uint8Array.of(74, 70, 73, 70, 0);
+var ICC_PROFILE = ascii2("ICC_PROFILE\0");
+var ADOBE = ascii2("Adobe");
+var PNG_DRAWING_CHUNKS = /* @__PURE__ */ new Set([
+  "IHDR",
+  "PLTE",
+  "IDAT",
+  "IEND",
+  "tRNS",
+  "cHRM",
+  "gAMA",
+  "iCCP",
+  "sBIT",
+  "sRGB",
+  "cICP",
+  "mDCV",
+  "cLLI",
+  "bKGD",
+  "hIST",
+  "pHYs",
+  "sPLT",
+  "acTL",
+  "fcTL",
+  "fdAT"
+]);
+function pngWithoutMetadata(bytes) {
+  const kept = new Kept(bytes.length);
+  kept.add(bytes.subarray(0, 8));
+  let at = 8;
+  let orientationKept = false;
+  while (at + 12 <= bytes.length) {
+    const length = numberAt(bytes, at, 4);
+    const type = typeAt(bytes, at + 4);
+    if (length > bytes.length - at - 12) {
+      return null;
+    }
+    const end = at + 12 + length;
+    if (PNG_DRAWING_CHUNKS.has(type)) {
+      kept.add(bytes.subarray(at, end));
+    } else if (type === "eXIf" && !orientationKept) {
+      orientationKept = true;
+      const orientation = exifOrientation(bytes.subarray(at + 8, at + 8 + length));
+      if (orientation !== 1) {
+        const data = new Uint8Array([...ascii2("eXIf"), ...orientationOnly(orientation)]);
+        kept.add(bigEndian(data.length - 4, 4));
+        kept.add(data);
+        kept.add(bigEndian(crc32(data), 4));
+      }
+    }
+    if (type === "IEND") {
+      return kept.bytes;
+    }
+    at = end;
+  }
+  return null;
+}
+var GIF_PLAYING_APPLICATIONS = [
+  "NETSCAPE2.0",
+  "ANIMEXTS1.0",
+  "ICCRGBG1012"
+].map(ascii2);
+function gifColourTable(packed) {
+  return packed & 128 ? 3 << (packed & 7) + 1 : 0;
+}
+function gifWithoutMetadata(bytes) {
+  const subBlocksEnd = (start) => {
+    let at2 = start;
+    while (at2 < bytes.length) {
+      const size = bytes[at2] ?? 0;
+      if (size === 0) {
+        return at2 + 1;
+      }
+      at2 += 1 + size;
+    }
+    return null;
+  };
+  if (bytes.length < 13) {
+    return null;
+  }
+  let at = 13 + gifColourTable(bytes[10] ?? 0);
+  if (at > bytes.length) {
+    return null;
+  }
+  const kept = new Kept(bytes.length);
+  kept.add(bytes.subarray(0, at));
+  while (at < bytes.length) {
+    switch (bytes[at]) {
+      case 44: {
+        if (at + 10 > bytes.length) {
+          return null;
+        }
+        const data = at + 10 + gifColourTable(bytes[at + 9] ?? 0);
+        const end = data < bytes.length ? subBlocksEnd(data + 1) : null;
+        if (end === null) {
+          return null;
+        }
+        kept.add(bytes.subarray(at, end));
+        at = end;
+        break;
+      }
+      case 33: {
+        const end = at + 2 < bytes.length ? subBlocksEnd(at + 2) : null;
+        if (end === null) {
+          return null;
+        }
+        const label = bytes[at + 1];
+        const plays = label === 255 && bytes[at + 2] === 11 && end >= at + 14 && GIF_PLAYING_APPLICATIONS.some((name) => startsWith2(bytes, name, at + 3));
+        if (label === 249 || label === 1 || plays) {
+          kept.add(bytes.subarray(at, end));
+        }
+        at = end;
+        break;
+      }
+      case 59:
+        kept.add([59]);
+        return kept.bytes;
+      default:
+        return null;
+    }
+  }
+  return null;
+}
+var WEBP_DRAWING_CHUNKS = /* @__PURE__ */ new Set([
+  "VP8X",
+  "ICCP",
+  "ANIM",
+  "ANMF",
+  "ALPH",
+  "VP8 ",
+  "VP8L"
+]);
+function webpWithoutMetadata(bytes) {
+  if (bytes.length < 12) {
+    return null;
+  }
+  const end = 8 + numberAt(bytes, 4, 4, true);
+  const chunks = end >= 12 && end <= bytes.length ? webpChunks(bytes.subarray(12, end)) : null;
+  if (chunks === null || chunks.length === 0) {
+    return null;
+  }
+  const kept = new Kept(chunks.length + 12);
+  kept.add(ascii2("RIFF"));
+  kept.add(littleEndian(chunks.length + 4, 4));
+  kept.add(ascii2("WEBP"));
+  kept.add(chunks);
+  const image = kept.bytes;
+  if (image.length > 20 && typeAt(image, 12) === "VP8X" && numberAt(image, 16, 4, true) > 0) {
+    const exif = webpChunkTypes(image.subarray(12)).includes("EXIF");
+    image[20] = (image[20] ?? 0) & ~12 | (exif ? 8 : 0);
+  }
+  return image;
+}
+function webpChunks(chunks) {
+  const kept = new Kept(chunks.length);
+  const frames = [];
+  let end = chunks.length;
+  let at = 0;
+  let orientationKept = false;
+  for (; ; ) {
+    if (at >= end) {
+      const frame = frames.pop();
+      if (frame === void 0) {
+        return kept.bytes;
+      }
+      kept.set(frame.size, littleEndian(kept.length - frame.size - 4, 4));
+      at = frame.resume;
+      end = frames.at(-1)?.end ?? chunks.length;
+      continue;
+    }
+    if (end - at < 8) {
+      return null;
+    }
+    const type = typeAt(chunks, at);
+    const size = numberAt(chunks, at + 4, 4, true);
+    if (size > end - at - 8) {
+      return null;
+    }
+    const data = at + 8;
+    at = Math.min(data + size + size % 2, end);
+    if (type === "ANMF") {
+      if (size < 16) {
+        return null;
+      }
+      frames.push({ end: data + size, resume: at, size: kept.length + 4 });
+      kept.add(chunks.subarray(data - 8, data + 16));
+      at = data + 16;
+      end = data + size;
+    } else if (WEBP_DRAWING_CHUNKS.has(type)) {
+      kept.add(chunks.subarray(data - 8, data + size));
+      if (size % 2 === 1) {
+        kept.add([0]);
+      }
+    } else if (type === "EXIF" && frames.length === 0 && !orientationKept) {
+      orientationKept = true;
+      const turned = exifOrientation(chunks.subarray(data, data + size));
+      if (turned !== 1) {
+        const exif = orientationOnly(turned);
+        kept.add(ascii2(type));
+        kept.add(littleEndian(exif.length, 4));
+        kept.add(exif);
+      }
+    }
+  }
+}
+function webpChunkTypes(chunks) {
+  const types = [];
+  let at = 0;
+  while (chunks.length - at >= 8) {
+    types.push(typeAt(chunks, at));
+    const size = numberAt(chunks, at + 4, 4, true);
+    at += 8 + size + size % 2;
+  }
+  return types;
+}
+
 // packages/board-core/dist/moves.js
 import { mkdir as mkdir4, rm as rm2 } from "node:fs/promises";
 import path5 from "node:path";
@@ -3434,6 +3899,72 @@ function tokenUse(events, window, now) {
   };
 }
 
+// packages/board-core/dist/turn-counters.js
+var TOKEN_KINDS = ["input", "output", "cache_read", "cache_write"];
+var USAGE_FIELD = {
+  input: "inputTokens",
+  output: "outputTokens",
+  cache_read: "cacheReadTokens",
+  cache_write: "cacheWriteTokens"
+};
+var UNKNOWN_LABEL = "unknown";
+function byKey(entries) {
+  return [...entries].toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, series]) => series);
+}
+var TurnCounters = class {
+  cliOf;
+  tokens = /* @__PURE__ */ new Map();
+  turns = /* @__PURE__ */ new Map();
+  /**
+   * `cliOf` names a citizen's CLI for an end logged before ends named theirs: a turn runs on the
+   * CLI its citizen's record names, which nothing changes after the citizen is added.
+   */
+  constructor(cliOf) {
+    this.cliOf = cliOf;
+  }
+  /** Counts a turn's end, `turn.completed` or `turn.failed`, and passes over any other event. */
+  add(event) {
+    if (event.type !== "turn.completed" && event.type !== "turn.failed") {
+      return;
+    }
+    const turn2 = TurnHistoryPayloadSchema.safeParse(event.payload);
+    if (!turn2.success) {
+      return;
+    }
+    const agent2 = event.actor;
+    const outcome = event.type === "turn.failed" ? "failed" : "completed";
+    const trigger = turn2.data.trigger;
+    const counted = JSON.stringify([agent2, outcome, trigger]);
+    this.turns.set(counted, {
+      agent: agent2,
+      outcome,
+      trigger,
+      turns: (this.turns.get(counted)?.turns ?? 0) + 1
+    });
+    const usage = turn2.data.usage;
+    if (usage === void 0) {
+      return;
+    }
+    const named = CliKindSchema.safeParse(event.payload["cli"]);
+    const cli = (named.success ? named.data : this.cliOf(agent2)) ?? UNKNOWN_LABEL;
+    const model = turn2.data.model ?? UNKNOWN_LABEL;
+    for (const kind of TOKEN_KINDS) {
+      const key = JSON.stringify([agent2, cli, model, kind]);
+      this.tokens.set(key, {
+        agent: agent2,
+        cli,
+        model,
+        kind,
+        tokens: (this.tokens.get(key)?.tokens ?? 0) + usage[USAGE_FIELD[kind]]
+      });
+    }
+  }
+  /** The counts so far, in an order that holds from one read to the next. */
+  read() {
+    return { tokens: byKey(this.tokens), turns: byKey(this.turns) };
+  }
+};
+
 // packages/board-core/dist/mutex.js
 var Mutex = class {
   tail = Promise.resolve();
@@ -3793,6 +4324,7 @@ function hashToken(token) {
 // packages/board-core/dist/board.js
 var SYSTEM_ACTOR = { name: "board", role: USER_ROLE };
 var CLOSING_ATTEMPTS = 3;
+var CHANNEL_POST_WAIT_MS = 24 * 36e5;
 function ownTurn(actor, turn2) {
   return turn2.agent === actor.name && turn2.scope === actor.scope && turn2.thread === actor.thread && turn2.channel === actor.channel && turn2.place === actor.place;
 }
@@ -5107,10 +5639,13 @@ ${DASHBOARD_LINE}
    * when it mentions the user, so the creator can put a wait on the user in; a post that asks the
    * reader counts wherever it is. A closed thread counts for nothing: its conversation has ended,
    * and a turn there could only read its posts and be refused a reply, while a wake queued before
-   * it closed, as for a mention, still runs there.
+   * it closed, as for a mention, still runs there. A top-level post in a project's channel, general
+   * or a workstream's, counts only for a reader it asks until it is `channelPostWaitMs` old, and
+   * then for every reader who has not read it, so a turn there for anything else reads it sooner.
    */
-  async unreadByConversation(actor) {
+  async unreadByConversation(actor, options = {}) {
     const { cursors, upto } = await this.digestSnapshot(actor.name);
+    const waited = this.now().getTime() - (options.channelPostWaitMs ?? CHANNEL_POST_WAIT_MS);
     const counts = /* @__PURE__ */ new Map();
     const threadCounts = /* @__PURE__ */ new Map();
     const unscoped = { name: actor.name, role: actor.role };
@@ -5118,11 +5653,15 @@ ${DASHBOARD_LINE}
       if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name || message.notice?.kind === "knowledge") {
         continue;
       }
-      const posted = parseChannelRef(message.channel).project ?? SOCIETY_SCOPE;
+      const project2 = parseChannelRef(message.channel).project;
+      const posted = project2 ?? SOCIETY_SCOPE;
       if (posted !== scope && scope !== SOCIETY_SCOPE) {
         continue;
       }
       const thread2 = threadOfPart(part);
+      if (thread2 === void 0 && project2 !== null && asked !== true && Date.parse(message.ts) > waited) {
+        continue;
+      }
       if (thread2 !== void 0) {
         let counted = threadCounts.get(thread2);
         if (counted === void 0) {
@@ -5546,9 +6085,9 @@ ${current.body}`);
   /**
    * Keeps an image a citizen's turn names by its path, read on the runner the turn runs on, which
    * refuses a file outside the turn's worktree, the citizen's home, and the system temp folder.
-   * Only the bytes of a PNG, JPEG, GIF, or WebP of at most `IMAGE_LIMIT_BYTES` are kept, checked
-   * here again whatever the runner said, under a new id outside the projection, so no runner
-   * mirrors them and no prompt carries them: a post shows the image by its `image:` address.
+   * Only a PNG, JPEG, GIF, or WebP of at most `IMAGE_LIMIT_BYTES` is kept, checked here again
+   * whatever the runner said, without its metadata, under a new id outside the projection, so no
+   * runner mirrors it and no prompt carries it: a post shows the image by its `image:` address.
    */
   async uploadImage(actor, input) {
     const args = VerbInputs.upload_image.parse(input);
@@ -5574,8 +6113,13 @@ ${current.body}`);
   }
   /**
    * Keeps `bytes` under a new id when they are a PNG, JPEG, GIF, or WebP of at most
-   * `IMAGE_LIMIT_BYTES`, and answers the markdown that shows them, described by `name`. `what`
-   * names the image in a refusal.
+   * `IMAGE_LIMIT_BYTES` that reads to its end, without its metadata (`withoutMetadata`), and
+   * answers the markdown that shows it, described by `name`. `what` names the image in a refusal.
+   * The limit is for the bytes as they came, as the route's body cap measures them, and bounds
+   * what is read; what is kept is checked against it too, since an orientation written smaller
+   * than the board writes it grows by a few bytes. The runner, the web's composer, and the app
+   * strip an image before they send it, and stripping it again changes nothing, but an older
+   * runner, page, or app sends one as it was.
    */
   async keepImage(actor, bytes, what, name) {
     const type = imageTypeOf(bytes);
@@ -5585,19 +6129,26 @@ ${current.body}`);
     if (bytes.byteLength > IMAGE_LIMIT_BYTES) {
       throw new BoardError("VALIDATION", `${what} is ${bytes.byteLength} bytes, over the ${IMAGE_LIMIT_BYTES} an image may be`);
     }
+    const kept = withoutMetadata(bytes);
+    if (kept === null) {
+      throw new BoardError("VALIDATION", `${what} does not read to its end as a ${IMAGE_KIND_NAMES[type]}, so its metadata cannot be told from its picture; save it again and send that copy`);
+    }
+    if (kept.byteLength > IMAGE_LIMIT_BYTES) {
+      throw new BoardError("VALIDATION", `${what} is ${kept.byteLength} bytes without its metadata, over the ${IMAGE_LIMIT_BYTES} an image may be`);
+    }
     return this.mutex.run(async () => {
       const id = this.newId();
-      await writeFileAtomic(this.paths.image(id), bytes);
+      await writeFileAtomic(this.paths.image(id), kept);
       await this.events.append("image.uploaded", actor.name, {
         id,
         type,
-        size: bytes.byteLength
+        size: kept.byteLength
       });
       const description = imageDescription(name);
       return {
         id,
         type,
-        size: bytes.byteLength,
+        size: kept.byteLength,
         markdown: `![${description}](${IMAGE_SCHEME}${id})`
       };
     });
@@ -6898,6 +7449,39 @@ ${rationale}`}`);
     const events = await this.events.readSince(null, Number.MAX_SAFE_INTEGER);
     return tokenUse(events, window, this.now());
   }
+  /**
+   * Every finished turn counted for Prometheus: seeded once from the whole event log, then moved
+   * by each turn's end this process appends, so reading the counts never reads the log. The server
+   * logs every turn's end itself; one another process appended would count from the next seed.
+   */
+  async countTurns() {
+    const clis = /* @__PURE__ */ new Map();
+    const counters = new TurnCounters((agent2) => clis.get(agent2) ?? null);
+    let waiting = [];
+    this.events.onAppend((event) => {
+      if (waiting === null) {
+        counters.add(event);
+      } else {
+        waiting.push(event);
+      }
+    });
+    const events = await this.events.readSince(null, Number.MAX_SAFE_INTEGER);
+    for (const agent2 of await this.listAgents()) {
+      clis.set(agent2.name, agent2.cli);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const event of events) {
+      seen.add(event.id);
+      counters.add(event);
+    }
+    for (const event of waiting) {
+      if (!seen.has(event.id)) {
+        counters.add(event);
+      }
+    }
+    waiting = null;
+    return counters;
+  }
   /** The board actions a finished turn took, from its transcript; null when it kept none. */
   async turnActions(agent2, turnId) {
     const known = this.actionCounts.get(turnId);
@@ -7095,6 +7679,7 @@ ${rationale}`}`);
         trigger: parsed.trigger.kind,
         ...parsed.trigger.heartbeat === void 0 ? {} : { heartbeat: parsed.trigger.heartbeat },
         session: parsed.session,
+        cli: parsed.cli,
         exitReason: parsed.exitReason,
         costUsd: parsed.costUsd,
         ...parsed.usage === null ? {} : { usage: parsed.usage },