opencode-zen-freex 0.2.8 → 0.2.9

package/capture.mjs

@@ -1,231 +0,0 @@
-// Recaptures fingerprint.json from a real OpenCode.
-//
-// The free tier reads the wording of the tools it knows by name out of the
-// request body and refuses the request when it differs from its own copy. That
-// copy moves with OpenCode, so the one held here goes stale — and a stale copy
-// looks exactly like a working one until somebody is refused. This is how a new
-// one is taken, so that refreshing it is a command and not an archaeology
-// exercise.
-//
-//   bun run capture            # writes fingerprint.json
-//   bun run capture -- --dry   # reports what changed, writes nothing
-//
-// Needs opencode on PATH (https://opencode.ai) and bun. Nothing goes to Zen: the
-// OpenCode under test is pointed at a server running here, and the request it
-// makes is the thing being read.
-
-import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { mkdtempSync } from "node:fs";
-import { rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { PROFILES } from "./core-tools.mjs";
-
-const PORT = Number(process.env.CAPTURE_PORT ?? 8791);
-const DRY = process.argv.includes("--dry");
-const HERE = import.meta.dir;
-const FINGERPRINT = join(HERE, "fingerprint.json");
-
-// The names Zen reads, by generation: 2.x sends `shell` where 1.x sends `bash`
-// and carries none of the others. Everything else a host declares is ignored.
-const READ = {
-  "1.x": ["bash", "glob", "grep", "read", "write", "edit"],
-  "2.x": ["shell", "read"],
-};
-
-// The capture host's own scratch directory and OS banner belong to the machine
-// the capture ran on, not to the tool. These are put back to something neutral
-// so the capture is not tied to one machine.
-const NEUTRALISE = [
-  [/Be aware: OS: [^\n]*/g, "Be aware: OS: linux, Shell: bash"],
-  [/Use `[^`]*` for temporary work outside the workspace\./g, "Use `/tmp` for temporary work outside the workspace."],
-  [/Use `[A-Za-z]:\\[^`]*`/g, "Use `/tmp`"],
-];
-// Zen compares roughly the first 700 characters and ignores the rest; 1200
-// leaves margin, and the tail is where a note to the model goes.
-const KEEP = 1200;
-
-const capturedPath = join(tmpdir(), `zen-capture-${process.pid}.json`);
-// A run that was killed leaves its file behind and a PID comes round again, so
-// this one is removed rather than read back as if it were this run's capture.
-rmSync(capturedPath, { force: true });
-// OpenCode makes more than one request (a short one for the title, then the
-// real one). The one worth reading is the longest, since it is the one that
-// carries the full toolset. It is kept here rather than written from the handler
-// as it arrives: two requests in flight at once would both be writing this one
-// file, and the writes interleave into it.
-let longest = { agent: null, body: "" };
-const server = Bun.serve({
-  port: PORT,
-  hostname: "127.0.0.1",
-  async fetch(request) {
-    const url = new URL(request.url);
-    if (url.pathname.endsWith("/models"))
-      return Response.json({ object: "list", data: [{ id: "big-pickle", object: "model", owned_by: "opencode" }] });
-    const body = await request.text();
-    if (body.length > longest.body.length) longest = { agent: request.headers.get("user-agent"), body };
-    return new Response(
-      [
-        'data: {"id":"c1","object":"chat.completion.chunk","created":1,"model":"big-pickle","choices":[{"index":0,"delta":{"role":"assistant","content":"OK"},"finish_reason":null}]}',
-        'data: {"id":"c1","object":"chat.completion.chunk","created":1,"model":"big-pickle","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}',
-        "data: [DONE]",
-        "",
-      ].join("\n\n"),
-      { headers: { "content-type": "text/event-stream" } },
-    );
-  },
-});
-
-const home = mkdtempSync(join(tmpdir(), "zen-capture-home-"));
-// Where OpenCode looks for its config is XDG_CONFIG_HOME/opencode, and the
-// three XDG directories are pointed at `home` below.
-const config = join(home, "config", "opencode", "opencode.json");
-await Bun.write(
-  config,
-  JSON.stringify({ provider: { opencode: { options: { baseURL: `http://127.0.0.1:${PORT}/v1` } } } }),
-);
-
-console.log(`listening on 127.0.0.1:${PORT}, running opencode against it`);
-let ran = true;
-const code = await new Promise((done) => {
-  const child = spawn("opencode", ["run", "-m", "opencode/big-pickle", "Say OK."], {
-    env: {
-      ...process.env,
-      XDG_DATA_HOME: join(home, "data"),
-      XDG_CONFIG_HOME: join(home, "config"),
-      XDG_CACHE_HOME: join(home, "cache"),
-    },
-    stdio: ["ignore", "ignore", "inherit"],
-  });
-  child.on("error", () => {
-    console.error("could not run opencode; install it from https://opencode.ai and put it on PATH");
-    ran = false;
-    done(1);
-  });
-  child.on("exit", (value) => done(value ?? 0));
-});
-server.stop(true);
-if (!ran) process.exit(1);
-// Written here, once nothing else can be writing it.
-if (longest.body.length) await Bun.write(capturedPath, JSON.stringify(longest));
-
-let request;
-try {
-  request = JSON.parse(readFileSync(capturedPath, "utf8"));
-} catch {
-  console.error("no request was captured; opencode did not reach the local server");
-  process.exit(1);
-}
-
-let body;
-try {
-  body = JSON.parse(request.body);
-} catch {
-  console.error("the captured request body is not JSON; nothing to read");
-  process.exit(1);
-}
-
-// Which generation this client is: the names it sends say so. It is read
-// before the tools are, since the two generations do not send the same names
-// and 2.x has to be recognised by `shell` rather than judged against 1.x's.
-const names = new Set((body.tools ?? []).map((raw) => (raw.function ?? raw)?.name));
-const generation = names.has("shell") ? "2.x" : "1.x";
-const read = READ[generation];
-
-const tools = {};
-for (const raw of body.tools ?? []) {
-  const tool = raw.function ?? raw;
-  if (!tool?.name || !read.includes(tool.name) || !tool.description) continue;
-  tools[tool.name] = {
-    name: tool.name,
-    description: NEUTRALISE.reduce((text, [find, to]) => text.replace(find, to), tool.description).slice(0, KEEP),
-    parameters: tool.parameters,
-  };
-}
-
-const missing = read.filter((name) => !tools[name]);
-if (missing.length) {
-  console.error(
-    `the captured request has no ${missing.join(", ")}; this OpenCode no longer sends them, so it cannot be captured this way`,
-  );
-  process.exit(1);
-}
-for (const [name, tool] of Object.entries(tools))
-  if (tool.description.length < 100) {
-    console.error(`${name}'s description looks truncated (${tool.description.length} chars); not writing`);
-    process.exit(1);
-}
-
-const required = generation === "2.x" ? ["shell", "read"] : ["bash", "glob", "grep", "read"];
-const absent = required.filter((name) => !tools[name]);
-if (absent.length) {
-  console.error(`a ${generation} request must carry ${absent.join(", ")}, and the capture does not`);
-  process.exit(1);
-}
-
-// Which protocol was captured, since each of 1.x's protocols bundles its own
-// provider-utils and a capture must not overwrite the ones it did not observe.
-// Anthropic is not one this can read: its tools carry `input_schema` where the
-// other two carry `parameters`, so read as the chat one it would write every
-// tool without its parameters and take the chat slot's provider-utils from an
-// anthropic client. Refused rather than written.
-if ((body.tools ?? []).some((raw) => (raw.function ?? raw)?.input_schema !== undefined)) {
-  console.error("the captured request is in the anthropic shape, which this script cannot read; nothing written");
-  process.exit(1);
-}
-const protocol = body.input !== undefined && body.messages === undefined ? "responses" : "chat";
-
-console.log(`\nagent:  ${request.agent}`);
-console.log(`tools:  ${Object.keys(tools).join(", ")}  (${generation}, ${protocol})`);
-if (code !== 0) console.log(`(opencode exited ${code}; its request was still captured)`);
-
-const agent = parseAgent(request.agent);
-if (agent.providerUtils) agent.providerUtils = { ...PROFILES[generation]?.agent?.providerUtils, [protocol]: agent.providerUtils[protocol] };
-
-const before = PROFILES[generation];
-const agentChanged = JSON.stringify(before?.agent) !== JSON.stringify(agent);
-let changed = 0;
-for (const name of Object.keys(tools)) {
-  if (JSON.stringify(before?.tools?.[name]) !== JSON.stringify(tools[name])) changed++;
-  console.log(`  ${name.padEnd(6)} ${JSON.stringify(before?.tools?.[name]) === JSON.stringify(tools[name]) ? "unchanged" : "CHANGED"}  ${tools[name].description.length} chars`);
-}
-if (agent.providerUtils)
-  console.log(`  agent  ${agentChanged ? "CHANGED" : "unchanged"}  ${protocol} provider-utils kept separate from the others`);
-
-if (DRY) {
-  const what = [changed ? `${changed} tool(s)` : null, agentChanged ? "the agent" : null].filter(Boolean);
-  console.log(`\n${what.length ? `${what.join(" and ")} would change.` : "Nothing would change."} Nothing written (--dry).`);
-  process.exit(what.length ? 1 : 0);
-}
-
-if (!changed && !agentChanged) {
-  console.log("\nnothing changed.");
-  process.exit(0);
-}
-
-const next = JSON.parse(readFileSync(FINGERPRINT, "utf8"));
-next.profiles[generation] = { agent, required, tools };
-await Bun.write(FINGERPRINT, JSON.stringify(next, null, 2) + "\n");
-console.log(`\nwrote ${FINGERPRINT} for ${generation}. Now run \`bun run check:gate\` and commit if it passes.`);
-
-// The User-Agent is stored the way agentFor() reads it back, which is not
-// necessarily the same split the raw header used.
-function parseAgent(agent) {
-  const twoPart = /^opencode\/(\d[^ ]*) ai-sdk\/provider-utils\/(\S+) (\S+)$/.exec(agent ?? "");
-  if (twoPart) {
-    const [, opencode, providerUtils, runtime] = twoPart;
-    return {
-      opencode,
-      providerUtils: { chat: providerUtils, responses: providerUtils, anthropic: providerUtils },
-      runtime,
-    };
-  }
-  const threePart = /^opencode\/([a-z]+)\/(\d[^/]*)\/([a-z-]+)$/.exec(agent ?? "");
-  if (threePart) {
-    const [, channel, opencode, client] = threePart;
-    return { channel, opencode, client };
-  }
-  console.error(`\ncould not read \`${agent}\` as an OpenCode User-Agent; write PROFILES[${generation}].agent by hand`);
-  process.exit(1);
-}

package/limits-audit.mjs

@@ -1,340 +0,0 @@
-// Asks the route which free models it still offers, groups them by the upstream
-// model serving them, and says which look under-declared.
-//
-//   bun run limits:audit
-//
-// Why this exists. Zen's catalogue is where this plugin declares limits from,
-// and two of the ids it publishes were declared far below what the model does:
-// `deepseek-v4.1-flash-free` at 200000/32000 against 1048576/384000, and
-// `mimo-v2.6-flash-free` at 200000/32000 against 1048576/131072. Both were found
-// by hand, one id at a time. What makes them findable without reading every id
-// by eye is that the route answers `x-opencode-upstream-model-id` on every
-// request: two ids naming one upstream model are one capability, so a
-// declaration that differs inside such a group is the question worth asking.
-//
-// What this does not do: measure a window, or write anything. A window costs a
-// prompt of about a million tokens — minutes and megabytes — and belongs to the
-// one id a signal has already pointed at; the numbers live in limits.mjs and are
-// put there by a measurement, never by a script. What this does ask is cheap:
-// one request of `max_tokens: 1000000` per offered id that speaks the chat
-// shape, stopped as soon as it starts writing. An upstream that validates the
-// ceiling refuses and names its own; one that does not just begins to answer and
-// is cut off after the first chunk. Either way the cost is a handful of tokens,
-// and a 410 or a 400 for a model that is gone is visible in the same request.
-// An id the snapshot places on another protocol is listed and not asked.
-//
-// The offered set is the listing's, not the catalogue's: Zen's /v1/models
-// carries 10 of the 40 free ids the catalogue still describes, and a plugin
-// only ever offers what the listing has. Auditing the other 30 reports a page
-// of `Model is unavailable` about models nobody can pick.
-//
-// What is reported, per offered id: the upstream model and the ids sharing it,
-// the ceiling a refusal named, the window a refusal named, and the status. The
-// candidates at the end are the reason to run it.
-//
-// Exit code is 0 when at least one offered id answered, 1 when none did: being
-// unable to ask is not a finding about limits.
-
-import { fileURLToPath } from "node:url";
-import { PROFILES } from "./core-tools.mjs";
-import { LIMITS, limitOverrides, namedContextWindow, namedOutputCap } from "./limits.mjs";
-import { SDK, bootstrapProtocols, isFree } from "./models.mjs";
-import { CATALOG, DEFAULT_BASE } from "./provider.mjs";
-import { chatRequest } from "./tools-smoke.mjs";
-
-const BASE = process.env.ZEN_BASE_URL ?? DEFAULT_BASE;
-const CATALOG_URL = process.env.ZEN_CATALOG_URL ?? CATALOG;
-const GENERATION = process.env.ZEN_GENERATION ?? "1.x";
-const READ_BUDGET = 4096;
-const ASKED_CEILING = 1_000_000;
-// How many ids are asked at once. Each ask stops as soon as the answer starts,
-// so the connection and the upstream load stay modest while the 45 s abort of
-// one id no longer holds up every id behind it.
-const POOL = 4;
-
-// The ids the plugin would offer: the listing's, kept where the catalogue calls
-// them free — or, for an id neither the catalogue nor the docs describe, where
-// the id names itself free and nothing else names its protocol, which is what
-// models.mjs offers on its own say-so. An id the snapshot already calls
-// something this plugin has no SDK for is not offered by anyone: `jev-1.13-free`
-// is SystemOne, and stays out here for the same reason buildModels leaves it out.
-// "Free" is models.mjs's own answer, retirement included, so the audited set and
-// the offered set cannot drift apart. Exported for the tests.
-export function offeredIds(listing, catalog, snapshot = bootstrapProtocols) {
-  return listing.filter((id) => {
-    const protocol = snapshot?.[id];
-    if (protocol !== undefined && !Object.hasOwn(SDK, protocol)) return false;
-    const model = catalog?.[id];
-    if (!model) return /-free$/.test(id);
-    return isFree(id, model);
-  });
-}
-
-// Offered ids by the upstream model serving them, which is the route's own
-// answer and not a guess from the id's shape.
-export function groupByUpstream(rows) {
-  const groups = new Map();
-  for (const row of rows) {
-    if (!row.upstream) continue;
-    groups.set(row.upstream, [...(groups.get(row.upstream) ?? []), row]);
-  }
-  return groups;
-}
-
-// What is worth a measurement, in the order it should be read. `covered` are the
-// ids limits.mjs already carries evidence for, which are said once and not
-// raised again. Exported for the tests.
-export function findings(rows, covered = new Set()) {
-  const out = [];
-  for (const row of rows) {
-    const declared = row.declared ?? {};
-    // An id limits.mjs already carries evidence for is not asked for again: its
-    // numbers are in the table and repeating them here would bury what is new.
-    // Its status is still printed in the table above, so a model that dies is
-    // not hidden by this — only its numbers stop being a question.
-    if (covered.has(row.id)) continue;
-    if (row.ceiling !== undefined && row.ceiling !== declared.output)
-      out.push(
-        `${row.id}: the route names a ceiling of ${row.ceiling} completion tokens, the catalogue declares ${declared.output ?? "none"}`,
-      );
-    if (row.window !== undefined && row.window !== declared.context)
-      out.push(
-        `${row.id}: a refusal named a window of ${row.window}, the catalogue declares ${declared.context ?? "none"}`,
-      );
-    const named = row.ceiling !== undefined || row.window !== undefined;
-    // A model that does not speak the shape this audit asks with is not a limits
-    // finding and must not sit in this list for ever: it is said once, beside the
-    // ids that were not asked at all.
-    if (protocolScoped(row)) continue;
-    if (row.status !== 200 && row.status !== 0 && !named) {
-      // What is left is worth reading: a 410, and a 400 that named nothing. A 0
-      // is a question that was never answered — timeout, DNS, a closed socket —
-      // and the audit's own rule is that being unable to ask is not a finding
-      // about limits, so the id, its status and its message stay in the table.
-      out.push(`${row.id}: HTTP ${row.status}${row.says ? ` — ${row.says}` : ""}`);
-    }
-  }
-  for (const [upstream, list] of groupByUpstream(rows)) {
-    const largest = (axis) => Math.max(...list.map((row) => row.declared?.[axis] ?? 0));
-    if (list.length < 2) continue;
-    if (new Set(list.map((row) => `${row.declared?.context}/${row.declared?.output}`)).size < 2) continue;
-    for (const row of list) {
-      if (covered.has(row.id)) continue;
-      if ((row.declared?.context ?? 0) >= largest("context") && (row.declared?.output ?? 0) >= largest("output"))
-        continue;
-      const siblings = list
-        .filter((other) => other.id !== row.id)
-        .map((other) => `${other.id} (${other.declared?.context}/${other.declared?.output})`)
-        .join(", ");
-      out.push(
-        `${row.id}: declared ${row.declared?.context}/${row.declared?.output}, and ${upstream} is also served as ${siblings}`,
-      );
-    }
-  }
-  return out;
-}
-
-function says(text) {
-  const match = text.match(/"(?:message|param)"\s*:\s*"([^"]{0,160})"/);
-  if (match) return match[1];
-  // Some upstreams refuse in words that are not under a `message` key at all,
-  // and a refusal nobody can read is not a finding.
-  const flat = text.replace(/\s+/g, " ").trim();
-  return flat ? flat.slice(0, 160) : "";
-}
-
-// A refusal that names the protocol rather than a limit. This audit asks the
-// chat shape, so a model that speaks Responses or Messages answers by saying so;
-// that is the host's business, not a limit to measure. The wording has to name
-// another shape or say it cannot be spoken at all: `format` alone is how an
-// ordinary `invalid request format` is worded, which is a question that was
-// asked and refused and belongs in the candidate list, not beside the ids that
-// were never asked.
-const OTHER_SHAPE = /protocol|\b(?:responses|messages)\b|anthropic/i;
-
-export function protocolScoped(row) {
-  return OTHER_SHAPE.test(row?.says ?? "");
-}
-
-async function getJSON(url) {
-  const response = await fetch(url, { signal: AbortSignal.timeout(30000) });
-  if (!response.ok) throw new Error(`${url} answered HTTP ${response.status}`);
-  return response.json();
-}
-
-// One cheap question per id. The ceiling asked for is past anything this route
-// serves, so an upstream that validates it says what it allows, and the stream
-// is dropped as soon as it starts rather than paying for an answer nobody reads.
-async function ask(id, names) {
-  const { headers, body } = chatRequest({
-    model: id,
-    generation: GENERATION,
-    profile: PROFILES[GENERATION],
-    names,
-    maxTokens: ASKED_CEILING,
-  });
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 45000);
-  try {
-    const response = await fetch(`${BASE}/chat/completions`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal: controller.signal,
-    });
-    let text = "";
-    if (response.ok) {
-      const reader = response.body?.getReader();
-      if (reader) {
-        const decoder = new TextDecoder();
-        while (text.length < READ_BUDGET) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          text += decoder.decode(value, { stream: true });
-        }
-      }
-    } else {
-      text = (await response.text()).slice(0, READ_BUDGET);
-    }
-    const upstream = response.headers.get("x-opencode-upstream-model-id") ?? undefined;
-    const endpoint = response.headers.get("x-opencode-endpoint-id") ?? undefined;
-    // limits.mjs reads refusals, and a refusal is the only place this route
-    // states a limit. The body of a 200 is the model's own prose, which an
-    // answer about token limits — or one that merely mentions them — would turn
-    // into a ceiling nobody stated, and a `named` row then skips its status line
-    // in findings() as well.
-    return {
-      status: response.status,
-      upstream,
-      endpoint,
-      window: response.ok ? undefined : namedContextWindow(text),
-      ceiling: response.ok ? undefined : namedOutputCap(text),
-      says: response.ok ? "" : says(text),
-    };
-  } catch (error) {
-    return { status: 0, says: error.message, upstream: undefined, endpoint: undefined };
-  } finally {
-    clearTimeout(timer);
-    controller.abort();
-  }
-}
-
-// Whether this module is the file that was run rather than one the tests
-// import. `import.meta.main` is the direct answer and the one Bun gives, but it
-// arrived in Node 22.18 and nothing before that has it — and an audit that cannot
-// tell whether it was run is an audit that reports success without asking.
-function invokedDirectly() {
-  // `typeof` rather than `??`: a runtime without the property throws on the
-  // member access itself, where there is nothing to fall back from.
-  if (typeof import.meta.main === "boolean") return import.meta.main;
-  try {
-    return process.argv[1] !== undefined && fileURLToPath(import.meta.url) === process.argv[1];
-  } catch {
-    return undefined;
-  }
-}
-
-// Only a run asks the route. The tests import the helpers above and must not
-// reach the network.
-const entry = invokedDirectly();
-if (entry === undefined) {
-  console.error(
-    "Could not tell whether this file was run or imported, so nothing was asked: neither import.meta.main nor process.argv[1] named an entry point. Run it with `bun run limits:audit`.",
-  );
-  process.exit(1);
-}
-
-if (entry) {
-  // A generation nobody captured is a typo or a Zen that has moved on, and is
-  // worth saying in one line rather than throwing a TypeError out of the first
-  // line of the run.
-  if (!Object.hasOwn(PROFILES, GENERATION)) {
-    console.error(
-      `limits audit — ZEN_GENERATION "${GENERATION}" is not a captured generation (${Object.keys(PROFILES).join(", ")})`,
-    );
-    process.exitCode = 1;
-  } else {
-    try {
-      await run();
-    } catch (error) {
-      // Being unable to ask is not a finding about limits, so it is a sentence
-      // and an exit code rather than a stack trace about a fetch that failed.
-      console.error(`\nlimits audit — unable to ask: ${error?.message ?? error}`);
-      console.error("The route or the catalogue could not be read. Check the network and ZEN_BASE_URL, then ask again.");
-      process.exitCode = 1;
-    }
-  }
-}
-
-async function run() {
-  const names = [...PROFILES[GENERATION].required];
-  const [listing, catalog] = await Promise.all([getJSON(`${BASE}/models`), getJSON(CATALOG_URL)]);
-  const models = catalog?.opencode?.models ?? {};
-  const ids = offeredIds(
-    (Array.isArray(listing?.data) ? listing.data : []).map((entry) => entry?.id).filter(Boolean),
-    models,
-  );
-  const free = Object.keys(models).filter(
-    (id) => /free/i.test(id) || (models[id].cost?.input === 0 && models[id].cost?.output === 0),
-  );
-  console.log(`limits audit — ${BASE}`);
-  console.log(`${ids.length} free ids are offered; the catalogue still describes ${free.length}\n`);
-
-  const rows = [];
-  // This asks the chat shape only. An id the snapshot places on another protocol
-  // is left to the host that speaks it, and said once rather than reported as a
-  // finding it cannot be.
-  const asked = ids.filter((id) => (bootstrapProtocols[id] ?? "chat") === "chat");
-  const elsewhere = ids.filter((id) => !asked.includes(id));
-  // The asks are independent, and each one can sit until its 45 s abort, so a
-  // few run together: 4 at a time overlaps the waiting without opening a
-  // connection per id. Answers are gathered first and printed in `asked` order,
-  // which is the order the listing gave.
-  for (let at = 0; at < asked.length; at += POOL) {
-    const batch = await Promise.all(
-      asked.slice(at, at + POOL).map(async (id) => {
-        const answer = await ask(id, names);
-        return { id, declared: models[id]?.limit ?? {}, ...answer };
-      }),
-    );
-    rows.push(...batch);
-  }
-
-  // What the plugin declares is the catalogue's limit with limits.mjs over it,
-  // so that is what is printed; the catalogue's own pair is shown beside it when
-  // the two differ, since that is the under-report being answered.
-  for (const { id, declared, ...answer } of rows) {
-    const effective = { ...declared, ...limitOverrides(id, declared) };
-    const moved = effective.context !== declared.context || effective.output !== declared.output;
-    const pair = (limit) => `${limit.context ?? "—"}/${limit.output ?? "—"}`;
-    const mark = answer.status === 200 ? "  " : "! ";
-    console.log(
-      `${mark}${id.padEnd(34)} ${pair(effective).padStart(17)}` +
-        `${moved ? `  (catalogue ${pair(declared)})` : ""}  ${answer.status}` +
-        `${answer.upstream ? `  ${answer.upstream}${answer.endpoint ? ` via ${answer.endpoint}` : ""}` : ""}` +
-        `${answer.ceiling !== undefined ? `  ceiling=${answer.ceiling}` : ""}${answer.window !== undefined ? `  window=${answer.window}` : ""}` +
-        `${answer.says ? `  — ${answer.says}` : ""}`,
-    );
-  }
-
-  const answered = rows.filter((row) => row.status === 200);
-  const candidates = findings(rows, new Set(Object.keys(LIMITS)));
-  const skipped = [...elsewhere, ...rows.filter(protocolScoped).map((row) => row.id)];
-  if (skipped.length)
-    console.log(
-      `\nnot asked, this audit asks the chat shape only: ${skipped.map((id) => `${id}${bootstrapProtocols[id] ? ` (${bootstrapProtocols[id]})` : ""}`).join(", ")}`,
-    );
-  console.log(`\nlimits.mjs already carries evidence for: ${Object.keys(LIMITS).join(", ")}`);
-  console.log(`\n${candidates.length} candidate${candidates.length === 1 ? "" : "s"}:`);
-  for (const line of candidates) console.log(`  ${line}`);
-  if (!candidates.length) console.log("  none — every offered id is either measured or declared at what the route states");
-
-  if (!answered.length) {
-    console.log(
-      asked.length
-        ? "\nNothing answered, so this says nothing about limits. Check the network or ZEN_BASE_URL and ask again."
-        : "\nNo offered id speaks the chat shape, so nothing was asked and this says nothing about limits.",
-    );
-    process.exitCode = 1;
-  }
-}