@kubitnodes/stellaris 0.4.0 → 0.4.2

package/dist/cli/index.js

@@ -370,6 +370,18 @@ function mergeQuota(previous, next) {
     windows: [...windows.values()]
   };
 }
+var UNKNOWN_LIMIT_HOLD_MS = 30 * 6e4;
+function stopsTurns(quota) {
+  return quota.status === "limited" && !(quota.source === "read" && quota.extraUsage?.enabled === true);
+}
+function limitHold(quota, now) {
+  if (!stopsTurns(quota)) {
+    return null;
+  }
+  const known = quota.limitedUntil !== null;
+  const until = quota.limitedUntil ?? new Date(Date.parse(quota.observedAt) + UNKNOWN_LIMIT_HOLD_MS).toISOString();
+  return Date.parse(until) > now.getTime() ? { until, known } : null;
+}
 function readings(quota) {
   const windows = quota.windows.map((window) => `${window.key}=${window.usedPercent === null ? "?" : Math.round(window.usedPercent)}@${window.resetsAt === null ? "?" : Math.round(Date.parse(window.resetsAt) / 6e4)}`).toSorted();
   return windows.join(",");
@@ -699,12 +711,16 @@ var RunnerSchema = z5.object({
 function runnerPause(runner2, cli) {
   return runner2.paused ?? runner2.pausedClis?.[cli];
 }
-function heldOn(runners, runner2, cli) {
+function runnerLimitHold(runner2, cli, now) {
+  const quota = runner2.quotas?.[cli];
+  return quota === void 0 ? null : limitHold(quota, now);
+}
+function heldOn(runners, runner2, cli, now) {
   if (runner2 === void 0 || cli === null) {
     return false;
   }
   const record = runners.find((each) => each.name === runner2);
-  return record !== void 0 && runnerPause(record, cli) !== void 0;
+  return record !== void 0 && (runnerPause(record, cli) !== void 0 || runnerLimitHold(record, cli, now) !== null);
 }
 var ProposalKindSchema = z5.enum([
   "role",
@@ -1024,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]) {
@@ -1445,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() });
@@ -1600,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. */
@@ -1993,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. */
@@ -2244,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.
@@ -2284,7 +2320,7 @@ var RunnerConfigSchema = z13.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.4.0";
+var STELLARIS_VERSION = "0.4.2";
 
 // packages/shared/dist/mentions.js
 import { parse, postprocess, preprocess } from "micromark";
@@ -2976,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";
@@ -3418,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();
@@ -3777,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;
 }
@@ -3900,8 +4448,10 @@ function plain(value) {
     return "";
   return JSON.stringify(value);
 }
-function sentence(summary) {
-  return summary.trim().replace(/\.+$/, "");
+var SENTENCE_END = /[.…?!]["'”’»)\]}*_]*$/u;
+function asSentence(text) {
+  const trimmed = text.trim();
+  return SENTENCE_END.test(trimmed) ? trimmed : `${trimmed}.`;
 }
 function skillSummary(data, body) {
   const description = data["description"];
@@ -5089,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 };
@@ -5100,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) {
@@ -5485,7 +6042,7 @@ ${current.body}`);
         name: args.name,
         reason: args.reason
       });
-      await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${args.name} removed from the society by ${actor.name}: ${sentence(withoutMentions(args.reason))}. Every citizen's skills index stops listing it from its next turn.`);
+      await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${args.name} removed from the society by ${actor.name}: ${asSentence(withoutMentions(args.reason))} Every citizen's skills index stops listing it from its next turn.`);
       return removed;
     });
   }
@@ -5528,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);
@@ -5556,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);
@@ -5567,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})`
       };
     });
@@ -6555,7 +7124,7 @@ ${args.summary}`);
       });
       const thread2 = await this.openThreadUnlocked(actor.name, this.proposalThreadOpening(proposal2));
       const rationale = args.rationale.trim();
-      await this.appendThreadMessage(actor.name, thread2.id, `Proposal ${proposal2.id}: ${describeCharter(proposal2.kind, proposal2.charter)}.${rationale.length === 0 ? "" : `
+      await this.appendThreadMessage(actor.name, thread2.id, `Proposal ${proposal2.id}: ${asSentence(describeCharter(proposal2.kind, proposal2.charter))}${rationale.length === 0 ? "" : `
 
 ${rationale}`}`);
       return proposal2;
@@ -6880,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);
@@ -7077,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 },
@@ -7259,7 +7862,7 @@ ${rationale}`}`);
       const ts = this.now().toISOString();
       const landed = current.onDone !== "none";
       if (landed) {
-        await this.postTaskNote(actor.name, current, input.ok ? `${sentence(input.detail)}.` : `Landing failed: ${sentence(input.detail)}. The task waits at its last stage for its participants to reshape the plan.`, input.ok ? { action: "landed", stage: current.stage, to: null } : { action: "reopened", stage: current.stage, to: current.stage });
+        await this.postTaskNote(actor.name, current, input.ok ? asSentence(input.detail) : `Landing failed: ${asSentence(input.detail)} The task waits at its last stage for its participants to reshape the plan.`, input.ok ? { action: "landed", stage: current.stage, to: null } : { action: "reopened", stage: current.stage, to: current.stage });
       }
       if (input.ok) {
         const task3 = await this.writeEndedTask(actor.name, location.project, {
@@ -7279,7 +7882,7 @@ ${rationale}`}`);
           await this.refreshMember(name);
         }
         if (landed) {
-          await this.appendMessage(actor.name, channelRef(location.project, task3.channel), `Task ${task3.id} "${task3.title}" is done: ${sentence(input.detail)}.`);
+          await this.appendMessage(actor.name, channelRef(location.project, task3.channel), `Task ${task3.id} "${task3.title}" is done: ${asSentence(input.detail)}`);
         }
         return task3;
       }
@@ -7990,7 +8593,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       files: taken.files.length,
       ...meta
     });
-    await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill2.name} ${replaced ? "updated in" : "promoted to"} the society: ${sentence(skill2.summary)}. Every citizen's skills index now lists it.`);
+    await this.appendMessage(SYSTEM_ACTOR.name, "general", `Skill ${skill2.name} ${replaced ? "updated in" : "promoted to"} the society: ${asSentence(skill2.summary)} Every citizen's skills index now lists it.`);
     return replaced;
   }
   /**
@@ -8237,7 +8840,7 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
     });
     const purpose = withoutMentions(input.purpose);
     await this.appendMessage(SYSTEM_ACTOR.name, ref, `Channel ${ref} opened: ${purpose}`);
-    await this.appendMessage(SYSTEM_ACTOR.name, channelRef(input.project, "general"), `Channel ${ref} opened by ${by}: ${purpose}. Subscribe to it to follow its posts; its tasks and mentions reach whoever they concern either way.`);
+    await this.appendMessage(SYSTEM_ACTOR.name, channelRef(input.project, "general"), `Channel ${ref} opened by ${by}: ${asSentence(purpose)} Subscribe to it to follow its posts; its tasks and mentions reach whoever they concern either way.`);
     return ref;
   }
   /**
@@ -8660,17 +9263,18 @@ ${charter.purpose}
     return kept > lease ? new Date(kept).toISOString() : null;
   }
   /**
-   * The lease a holder keeps while the user's pause holds its turns in the task's project
-   * (`heldOn`), when later than the one it has, else null. It is renewed for a full lease once less
-   * than half is left, as for a pending cron, so it never lapses while the holder cannot take a
-   * turn there, and after the resume the holder has at least half a lease to come back to it.
+   * The lease a holder keeps while the user's pause, or its CLI's limit, holds its turns in the
+   * task's project (`heldOn`), when later than the one it has, else null. It is renewed for a full
+   * lease once less than half is left, as for a pending cron, so it never lapses while the holder
+   * cannot take a turn there, and after the resume or the reset the holder has at least half a
+   * lease to come back to it.
    */
   async pausedLease(task2, runners, runner2, now) {
     if (task2.claimedBy === void 0 || task2.leaseExpiresAt === void 0) {
       return null;
     }
     const holder = await this.readAgent(task2.claimedBy).catch(() => null);
-    if (holder === null || !heldOn(runners, runner2, holder.cli)) {
+    if (holder === null || !heldOn(runners, runner2, holder.cli, now)) {
       return null;
     }
     const lease = Date.parse(task2.leaseExpiresAt);
@@ -8761,9 +9365,9 @@ ${charter.purpose}
       });
     }
     const verdict = outcome === "approved" ? "Approved" : "Rejected";
-    const why = reason === void 0 ? "" : ` Reason: ${reason}.`;
+    const why = reason === void 0 ? "" : ` Reason: ${asSentence(reason)}`;
     const result = provision === void 0 ? "" : ` Provisioned: ${Object.entries(provision).map(([key, value]) => `${key} ${plain(value)}`).join(", ")}.`;
-    const post = `${verdict}: ${describeCharter(proposal2.kind, proposal2.charter)}.${why}${result}`;
+    const post = `${verdict}: ${asSentence(describeCharter(proposal2.kind, proposal2.charter))}${why}${result}`;
     await this.appendThreadMessage(actor.name, thread2.id, actor.name === SYSTEM_ACTOR.name ? withoutMentions(post) : post, { step: { action: outcome } });
     await this.endThreadOf(proposalId, actor.name, outcome);
     return decision;
@@ -9040,7 +9644,11 @@ runner.command("add <name>").description("Register a runner and print its token
 runner.command("list").description("List runners and what they offer").action(async () => {
   const board = await open3();
   const runners = await board.listRunners();
-  print(runners, () => runners.length === 0 ? "No runners yet; add one with `runner add <name>`." : runners.map((each) => `${each.name}  ${each.status}${each.paused === void 0 ? "" : "  paused"}  ${each.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}${Object.keys(each.pausedClis ?? {}).map((cli) => `  ${cli} paused`).join("")}`).join("\n"));
+  const now = /* @__PURE__ */ new Date();
+  print(runners, () => runners.length === 0 ? "No runners yet; add one with `runner add <name>`." : runners.map((each) => `${each.name}  ${each.status}${each.paused === void 0 ? "" : "  paused"}  ${each.os}${each.version === void 0 ? "" : `  v${each.version}`}  ${each.clis.join(",") || "no CLIs yet"}${each.capabilities.length === 0 ? "" : `  ${each.capabilities.join(",")}`}${Object.keys(each.pausedClis ?? {}).map((cli) => `  ${cli} paused`).join("")}${each.clis.map((cli) => {
+    const hold = runnerLimitHold(each, cli, now);
+    return hold === null ? "" : `  ${cli} held until ${hold.until}`;
+  }).join("")}`).join("\n"));
 });
 for (const [verb, paused] of [
   ["pause", true],