cortad 0.3.8 → 0.3.10

package/lib/auto-reach.mjs

@@ -19,15 +19,53 @@ const keyOf = (m) => `${m.method} ${m.path}`;
 // `asked()`: true once the agent's ask waits, so a round stops between two sends to take it.
 // `report(answers)`: what each test request met, for the server (POST /local/:box/reached). Each round
 // opens with an empty list, which says this command sends them, so status stops asking the agent to;
-// the caller posts it once per connection.
-export function makeAutoReach({ status, runner, waiting, origin, signIn, stampOf, asked = () => false, report = async () => {}, say, fetchImpl = fetch }) {
+// the caller posts it once per connection. Each answer is reported as it lands: reported only when
+// its round ended, one endpoint that took 55 seconds held every faster one's answer back with it.
+// `report` answering false, or failing, leaves its answers kept here and said again later: the server
+// hears them late, and the app is never asked again for the sake of a report that did not arrive.
+// What is kept is each endpoint's latest answer, so it is never more than the endpoints the app has
+// and nothing is dropped to make room. One report is out at a time; the first that fails stops the
+// rest, and the next is tried RETRY_MS later, twice as long after each failure up to RETRY_MAX_MS:
+// 250 answers behind a server that was not answering were 250 reports of 15 seconds each, one after
+// the other, and the fifty oldest were thrown away with their endpoints already marked as tested.
+// `roundMs`: past it a round starts no further request; the rows left are sent in the next round. It
+// bounds what a round starts, not a request already out (REACH_MS each) nor the connection as a whole.
+export const ROUND_MS = 90_000;
+const RETRY_MS = 5_000;
+const RETRY_MAX_MS = 60_000;
+const BATCH = 100;
+export function makeAutoReach({ status, runner, waiting, origin, signIn, stampOf, asked = () => false, report = async () => {}, say, fetchImpl = fetch, roundMs = ROUND_MS, now = Date.now }) {
   const sent = new Map();
   let n = 0;
   const next = () => ++n;
+  const kept = new Map();
+  let draining = null, retryAt = 0, backoff = 0;
+  const drain = async () => {
+    while (kept.size && now() >= retryAt) {
+      const batch = [...kept.values()].slice(0, BATCH);
+      const ok = await Promise.resolve().then(() => report(batch)).then((r) => r !== false, () => false);
+      if (!ok) {
+        // Said once per outage, so a card that is not moving has its reason in the terminal.
+        if (!backoff) say(`Cortad did not take what ${kept.size === 1 ? "1 test request" : `${kept.size} test requests`} met. They are kept here and sent again; your app is not asked again.`);
+        backoff = Math.min(backoff ? backoff * 2 : RETRY_MS, RETRY_MAX_MS);
+        retryAt = now() + backoff;
+        return;
+      }
+      backoff = 0;
+      // An endpoint answered again while its last answer was out keeps the newer one.
+      for (const a of batch) if (kept.get(a.door) === a) kept.delete(a.door);
+    }
+  };
+  const tell = (met = []) => {
+    for (const a of met) kept.set(a.door, a);
+    draining ??= drain().finally(() => { draining = null; });
+    return draining;
+  };
   // `ask`: the agent's call, { paths }: sent whatever was sent before, and answered with each line.
   // `wait`: when to look again: soon while the code is still being read, rarely once it is.
   return async function round(ask = null) {
-    await report([]).catch(() => {});
+    await Promise.resolve().then(() => report([])).catch(() => {});
+    await tell();
     const here = runner();
     const down = notUp(here);
     if (down) return { text: `${down} Nothing was sent.\nnext: status`, wait: 5_000 };
@@ -37,14 +75,22 @@ export function makeAutoReach({ status, runner, waiting, origin, signIn, stampOf
     if (!d) return { text: "Cortad did not answer with the list of endpoints. Nothing was sent.\nnext: status", wait: 30_000 };
     const pick = picked(d.contact, here.receipts, ask?.paths);
     const due = pick.sent.filter((m) => !m.excluded && (ask || sent.get(keyOf(m)) !== stampOf(m)));
-    const answers = due.length ? await sendOurs(due, { runner: here, origin: origin(), signIn, next, stop: () => !ask && asked(), fetchImpl }) : [];
-    // An app restarting under a request is no answer of the endpoint's: it is sent again next round.
+    const until = now() + roundMs;
+    let cut = false;
+    const answers = due.length ? await sendOurs(due, {
+      runner: here, origin: origin(), signIn, next, stop: () => (!ask && asked()) || (cut = now() >= until), fetchImpl,
+      onAnswer: (a, i) => { const met = outcomes([due[i]], [a]); if (met.length) void tell(met); },
+    }) : [];
+    await tell();
+    // A request that never reached the app (refused, or a GET cut off) is sent again next round. One
+    // that may have reached it, a POST reset or timed out, is not: sending it twice could do twice
+    // whatever it does. The agent's `reach` or an edit to its file sends it again.
     answers.forEach((a, i) => { if (!a.down) sent.set(keyOf(due[i]), stampOf(due[i])); });
-    const met = outcomes(due, answers);
-    for (let i = 0; i < met.length; i += 100) await report(met.slice(i, i + 100)).catch(() => {});
     const line = testedLine(answers);
     if (line) say(line);
-    return { text: reachText({ ...pick, sent: due.slice(0, answers.length) }, answers, `${here.port}, one at a time`), wait: d.read?.complete === true ? 60_000 : 5_000 };
+    // Rows the round's time left unsent are due in seconds, never a minute on. An ask of the agent's
+    // that stopped the round is taken within a second whatever this says.
+    return { text: reachText({ ...pick, sent: due.slice(0, answers.length) }, answers, `${here.port}, up to four at a time`), wait: !cut && !kept.size && d.read?.complete === true ? 60_000 : 5_000 };
   };
 }
 

package/lib/calls.mjs

@@ -1,23 +1,35 @@
 // What Cortad counts about its own tools: which one an agent called, from which client, how long it
 // took, how much text came back and, when it failed, under which code. The arguments and the answer
-// stay on this machine. Sent with the machine's own key, and a count that is lost is never retried:
-// it must not cost the tool call it describes.
+// stay on this machine. Sent with the machine's own key. A count that is lost is not sent again: it
+// must not cost the tool call it describes. One kind of call is: the agent's own test request
+// (`reach`), which Cortad counts as a try at fixing whatever holds Run. Lost, that try would go
+// uncounted, so its report is sent again, a few times and no more, always under the call's own id
+// (`callId`, made when the call arrived): the server takes an id once however often it arrives.
 import { randomUUID } from "node:crypto";
 
 const text = (v, max) => (typeof v === "string" && v ? v.slice(0, max) : undefined);
 
-export function makeReport({ api, token, version, fetchImpl = fetch, sessionId = randomUUID() }) {
-  return async ({ tool, durationMs, outputChars, errorCode, error, clientName, clientVersion }) => {
+const RETRIES = 3;
+const RETRY_MS = 400;
+
+export function makeReport({ api, token, version, fetchImpl = fetch, sessionId = randomUUID(), wait = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  return async ({ tool, callId, durationMs, outputChars, errorCode, error, clientName, clientVersion }) => {
     const key = token();
     if (!key) return;
-    const call = { tool, durationMs, outputChars, errorCode, error: text(error?.split("\n")[0], 512), clientName: text(clientName, 80), clientVersion: text(clientVersion, 40), serverVersion: version, sessionId };
-    try {
-      await fetchImpl(`${api}/mcp/calls`, {
-        method: "POST",
-        headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
-        body: JSON.stringify([call]),
-        signal: AbortSignal.timeout(3000),
-      });
-    } catch { /* lost */ }
+    const call = { tool, ...(callId ? { callId } : {}), durationMs, outputChars, errorCode, error: text(error?.split("\n")[0], 512), clientName: text(clientName, 80), clientVersion: text(clientVersion, 40), serverVersion: version, sessionId };
+    const tries = tool === "reach" && callId ? RETRIES : 1;
+    for (let n = 1; n <= tries; n++) {
+      try {
+        const res = await fetchImpl(`${api}/mcp/calls`, {
+          method: "POST",
+          headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+          body: JSON.stringify([call]),
+          signal: AbortSignal.timeout(3000),
+        });
+        // Taken, or refused for good: either way it is not sent again.
+        if (!res || res.ok || (res.status >= 400 && res.status < 500 && res.status !== 429)) return;
+      } catch { /* lost */ }
+      if (n < tries) await wait(n * RETRY_MS);
+    }
   };
 }

package/lib/contact-text.mjs

@@ -93,46 +93,29 @@ function doorLines(v) {
   return [...lines, ...inner.filter(Boolean).map((l) => `    ${l}`)];
 }
 
-// What a run would play, take and cost, said to the person: the conversations it starts with (of
-// those planned, the ones that fit in one run's time), the follow-ups apart, the time at the widest it
-// goes and what it costs on their own keys, or that no price could be read. "Written" was said of
-// conversations the run writes as it starts: "44 of the 79 trials written" beside "Trials: 39 written".
+// What a run would play, take and cost, in one short line the agent hands the person: how many
+// simulated users, about how long, and one price on their own key. A first run's price is what it is
+// expected to cost (`expected`, from factors measured on recorded first runs); the most it could cost,
+// the follow-ups and the pace at one request at a time were three more numbers nobody acted on.
 function readyLine(r) {
   if (!r || !r.trials) return null;
-  const soFar = r.reading ? " so far" : "";
-  const plays = has(r.planned) && r.planned > r.trials ? `${num(r.trials)} of the ${plural(r.planned, "conversation")} planned${soFar}, as many as fit in one run's time` : `${plural(r.trials, "conversation")}${soFar}`;
-  // Follow-ups are played only where something breaks: said apart, never in the count above.
-  const followUps = r.followUps ? `, and up to ${num(r.followUps)} more where something breaks` : "";
-  // The run widens only while replies keep pace, and a one-at-a-time app holds it to one: the time is
-  // a range when that is slower, and where fewer conversations fit at that pace, how many is said.
-  const upTo = has(r.atOne?.minutes) && r.atOne.minutes > r.minutes ? r.atOne.minutes : null;
-  const atOne = has(r.atOne?.trials) && r.atOne.trials < r.trials ? ` If your app answers one request at a time, about ${num(r.atOne.trials)} of them fit in that time.` : "";
-  const minutes = has(r.minutes) && `in about ${upTo ? `${num(r.minutes)} to ${plural(upTo, "minute")}` : plural(r.minutes, "minute")}`;
-  const size = [has(r.replies) && `about ${plural(r.replies, "reply", "replies")}`, minutes].filter(Boolean).join(" ");
-  const usd = (x) => `$${x.toFixed(2)}`;
-  // Some endpoints had no published rate or token counts: the price covers the others and says so.
-  // A first run is priced at what it is expected to cost (`expected`, from factors measured on recorded
-  // first runs) and the most it costs (`upTo`); a server from before `expected` sends the most alone.
-  // After a run of the app's own, as what that run measured. An older server sends a range (`usdHigh`).
-  // Where some endpoints had no price, on how many.
-  const amount = () => `${r.upTo ? "up to" : "about"} ${usd(r.usd)}${has(r.usdHigh) ? ` to ${usd(r.usdHigh)}` : ""}`;
-  const some = r.pricedOn ? `, on the ${num(r.pricedOn.endpoints)} of ${plural(r.pricedOn.of, "endpoint")} Cortad could price` : "";
-  const onKey = `on your ${r.provider ? `${r.provider} ` : ""}key${r.model ? ` for ${r.model}` : ""}`;
-  const both = r.upTo && has(r.expected);
-  // No price is said, as the card says it (guide.ts quoteLine), never left out.
-  const cost = has(r.usd)
-    ? ` ${both ? `It is expected to cost ${usd(r.expected)}${soFar} ${onKey}, and the most it costs is ${usd(r.usd)}` : `It costs ${amount()}${soFar} ${onKey}`}${some}${r.estimated ? ", estimated from the length of the text since your provider sent no token counts" : ""}.`
-    : " It runs on your app's own model keys; Cortad could not price it from what your app's model calls reported.";
-  // No rules is a fact of a finished read: said while the code is still being read, it was false a minute later.
-  const rules = !has(r.rules) || (r.reading && r.rules === 0) ? "" : r.rules === 0 ? " No rules of your own were read from the code, so replies are checked against general standards only." : ` Every reply is checked against the ${plural(r.rules, "rule")} read from your code.`;
-  return `For the person: a run plays ${plays}${followUps}${size ? `: ${size}` : ""}.${atOne}${cost}${rules}${r.reading ? " Your code is still being read; the run waits for it and plays every conversation it adds." : ""}`;
+  const plays = `${plural(r.trials, "simulated user")}${r.reading ? " so far" : ""}`;
+  const minutes = has(r.minutes) ? ` in about ${plural(r.minutes, "minute")}` : "";
+  const key = `your ${r.provider ? `${r.provider} ` : ""}key`;
+  const price = has(r.usd) ? `About $${(r.upTo && has(r.expected) ? r.expected : r.usd).toFixed(2)} on ${key}.` : `It runs on ${key}.`;
+  return `A run plays ${plays}${minutes}. ${price}`;
 }
+// No rules is a fact of a finished read, said before a run is spent on general standards alone: said
+// while the code is still being read, it was false a minute later.
+const noRulesLine = (r) => (r?.trials && r.rules === 0 && !r.reading ? "No rules of your own were read from the code, so replies are checked against general standards only." : null);
 
 // The endpoints no request has reached, as status lists them and reach sends them. `receipts`: doors
 // the App section says answered at once with their answer out of Cortad's sight, so not said here.
-export const unreached = (c, receipts = []) => {
+// `retests`: the doors whose test failed, listed again to be sent once more: reach takes them, the
+// list of endpoints no request reached does not.
+export const unreached = (c, receipts = [], { retests = false } = {}) => {
   const answered = new Set(receipts.map((x) => x.door));
-  return (c?.notCalled ?? []).filter((m) => !answered.has(`${m.method} ${m.path}`));
+  return (c?.notCalled ?? []).filter((m) => !answered.has(`${m.method} ${m.path}`) && (retests || !m.retest));
 };
 
 // One the server has no request for, or one listed on a field's name alone, is the agent's to send.
@@ -155,12 +138,15 @@ export function contactLines(c, data = [], receipts = []) {
   const said = data.map((s) => `Data: ${s}`);
   if (!c) return said;
   const proven = c.proven ?? [];
-  // No request yet is said by the App line and by the next step, not a third time here.
-  const lines = proven.length ? [`Endpoints that answered (${num(proven.length)}):`, ...proven.flatMap(doorLines)] : [];
+  // No request yet is said by the App line and by the next step, not a third time here. Endpoints
+  // that all answered only Cortad's own test request say so once, over the list: sixteen of them
+  // each said it under their own line, and the agent asked for a status it could read.
+  const alike = proven.length > 1 && proven.every((v) => v.standing === "fallback") && new Set(proven.map((v) => v.why)).size === 1;
+  const head = alike ? `Endpoints that answered (${num(proven.length)}), each only Cortad's own test request so far: ${proven[0].why}` : `Endpoints that answered (${num(proven.length)}):`;
+  const lines = proven.length ? [head, ...proven.flatMap((v) => doorLines(alike ? { ...v, standing: null } : v))] : [];
   const missing = unreached(c, receipts);
   if (missing.length) lines.push(`Endpoints found in your code that have not answered yet (${num(missing.length)}):`, ...missing.map(unreachedLine), ...[reachLine(missing)].filter(Boolean));
-  const ready = readyLine(c.ready);
-  if (ready) lines.push(ready);
+  for (const line of [readyLine(c.ready), noRulesLine(c.ready)]) if (line) lines.push(line);
   // What holds Run is the server's next line (src/local/contact.ts heldLine), said once: printed here
   // as well, ulaim's hold on its Qdrant was read twice in one status.
   return [...lines, ...said];

package/lib/keeping.mjs

@@ -38,19 +38,21 @@ function blockedRows(blocked) {
 // that command gives the app: a legal research API typed ENV=staging and was started on copies of
 // the test databases its default settings file names, where its library is empty.
 const AS_TYPED = "Your app is started with your own command as it is, on the databases that command gives it. Nothing is copied: a run writes into them once you say yes to each on the card.";
-export function makeKeeping({ root, work, ledgerFile, onPath, say, settings, launch, connections, hold = () => {}, typed = false }) {
+export function makeKeeping({ root, work, ledgerFile, onPath, say, settings, launch, connections, copies = () => [], hold = () => {}, typed = false }) {
   let pending = null;
   let now = null;
   let backing = null;
   let backedUp = false;
   let seen = 0;
   const tell = (lines) => { for (const line of lines) say(lower(line)); };
-  const held = (blocked) => tell(blocked.map((b) => `Run waits for your yes on the card in the browser: ${lower(b.why)}`));
+  const held = (blocked) => tell(blocked.map((b) => `One question for the person on the card in the browser: ${lower(b.why)}`));
 
   async function keepAll(started) {
     if (typed) {
       const none = async () => ({ env: {}, risks: [], copies: [], blocked: [], pass: [] });
-      now = { env: {}, risks: [], notes: [AS_TYPED], blocked: [], pass: [], stores: [], keeper: { keep: none, drop: async () => {} }, values: {}, started };
+      // The app's own command may still reach a Qdrant: the copies the hook makes there are dropped too.
+      const keeper = storeKeeper({ ledgerFile, values: {}, dirs: [] });
+      now = { env: {}, risks: [], notes: [AS_TYPED], blocked: [], pass: [], stores: [], keeper: { keep: none, drop: async () => {}, dropCopies: (c, s) => keeper.dropCopies(c, s) }, values: {}, started };
       tell(now.notes);
       return now;
     }
@@ -157,12 +159,15 @@ export function makeKeeping({ root, work, ledgerFile, onPath, say, settings, lau
       const k = await pending;
       pending = null;
       now = null;
+      await k?.keeper.dropCopies(copies(), k.stores).catch(() => {});
       await k?.keeper.drop();
     },
     // Once the app has stopped: a copy is dropped when nothing holds it open, and a store is stopped
     // only after its copy is gone.
     async close() {
-      await (await pending?.catch(() => null))?.keeper.drop().catch(() => {});
+      const k = await pending?.catch(() => null);
+      await k?.keeper.dropCopies(copies(), k.stores).catch(() => {});
+      await k?.keeper.drop().catch(() => {});
       await backing?.stop().catch(() => {});
     },
   };

package/lib/mcp.mjs

@@ -2,6 +2,7 @@
 // dependency. stdout carries protocol messages and nothing else; everything a person might read
 // goes to stderr. The tools are lib/verbs.mjs, one to one.
 
+import { randomUUID } from "node:crypto";
 import { SHOW } from "./read-text.mjs";
 
 export const PROTOCOL = "2025-06-18";
@@ -9,8 +10,8 @@ export const PROTOCOL = "2025-06-18";
 // Codex keeps only the first 512 characters self-contained and Claude Code shares about 4 KB across
 // every server, so the first paragraph stands alone and the whole stays under 1,500 characters.
 export const instructions = (spec = "cortad") => [
-  "Cortad tests the AI in this repository: simulated users written from the app's code talk to the app running on this machine, and every reply is checked. Cortad sends each AI endpoint a test request itself. status shows the app's port, what the reviews of the prompts and of the code around the model found, which endpoints answered and which failed at what file and line, and what a run would play and cost. The first run starts by itself; later runs when the person presses Run or asks.",
-  `Tell the person what status found in a few plain lines. Before you stop, start \`npx -y ${spec} wait\` as a background command: it returns when the next run ends, with what it found. After a run, call findings and fix the worst problem, then verify it; the person asked for these fixes when they connected Cortad. findings has each failure whole and findings numbers every rate. verify replays the failing conversations and says whether the failure is gone. field_connect gives the steps to connect production. dispute records a check that reads this app wrong.`,
+  "Cortad tests the AI in this repository: simulated users written from the app's code talk to the app running on this machine, and every reply is checked. Cortad sends each AI endpoint a test request itself. status says whether the app is up, what Cortad's audit of the AI code found, and what a run would play and cost. A run starts when the person presses Run in the browser or asks you.",
+  `Tell the person what status found in three or four short, plain lines, leaving out file paths, endpoints, status codes and setting names unless they ask. Before you stop, start \`npx -y ${spec} wait\` as a background command: it returns when the next run or verify ends, with what it found. After a run, call findings and tell the person what their users ran into and what you would change, worst first, three problems at most; the person then says which fix to make, and nothing is edited before their go. On their go, one fix at a time: verify replays the failing conversations and says whether the failure is gone, and a further round plays only when verify is called again. findings has each failure whole and findings numbers every rate. field_connect gives the steps to connect production. dispute records a check that reads this app wrong.`,
 ].join("\n\n");
 export const INSTRUCTIONS = instructions();
 
@@ -22,7 +23,7 @@ const ABOUT = ["status", "reach", "run", "run_status", "findings", "verify", "di
 
 export const TOOLS = [
   { name: "status", title: "Cortad status", annotations: readOnly,
-    description: "What Cortad found in this repository: whether the app is up and on which port, the reviews of its prompts and of the code around its model, each endpoint's answer to Cortad's test request or the file and line it failed at, the plan with runs left, and the latest run. Applies at the start of a session, right after a connect, and before a commit that changes prompts, tools, models or retrieval. With show, one section in full, in pages.",
+    description: "What Cortad found in this repository: whether the app is up and on which port, its audit of the prompts and of the code around the model, each endpoint's answer to Cortad's test request or the file and line it failed at, the plan with runs left, and the latest run. Applies at the start of a session, right after a connect, and before a commit that changes prompts, tools, models or retrieval. With show, one section in full, in pages.",
     inputSchema: { type: "object", properties: { show: { type: "string", enum: SHOW, description: "A section to list in full: rules, standards, journeys, endpoints, trials, records or reviews; or machine, what Cortad does on this machine." }, page: { type: "integer", minimum: 1, description: "The page of that list. Default 1." } }, additionalProperties: false } },
   { name: "reach", title: "Send Cortad's test requests again",
     description: "Sends Cortad's test request again to the endpoints status lists as failed or not yet answered, or to the paths named, from this machine to the app on its port. Each endpoint comes back with its HTTP status, its time and, when it is not 2xx, the start of what the app answered.",
@@ -69,8 +70,9 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
   return new Promise((resolve) => {
     let client = {};
     const sending = new Set();
-    const count = (tool, began, text, failure) => {
-      const sent = Promise.resolve(report({ tool, durationMs: Date.now() - began, outputChars: text.length, ...failure, ...client })).catch(() => {}).finally(() => sending.delete(sent));
+    // `callId`: this call's own name, made when it arrives and sent with every report of it (lib/calls.mjs).
+    const count = (tool, began, text, failure, callId) => {
+      const sent = Promise.resolve(report({ tool, callId, durationMs: Date.now() - began, outputChars: text.length, ...failure, ...client })).catch(() => {}).finally(() => sending.delete(sent));
       sending.add(sent);
     };
     let closed = false;
@@ -97,6 +99,7 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
       const { id, method, params } = msg;
       const notification = id === undefined || id === null;
       const began = Date.now();
+      const callId = randomUUID();
       try {
         switch (method) {
           case "initialize":
@@ -113,11 +116,11 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
             const name = params?.name;
             const verb = NAMES.has(name) && Object.hasOwn(verbs, name) ? verbs[name] : null;
             if (!verb) {
-              count("unknown", began, "", { errorCode: "unknown_tool" });
+              count("unknown", began, "", { errorCode: "unknown_tool" }, callId);
               return send(result(id, { content: [{ type: "text", text: `No tool ${String(name)}.` }], isError: true }));
             }
             const out = await verb(params?.arguments ?? {});
-            count(name, began, out.text, out.isError ? { errorCode: out.code ?? "refused", error: out.why } : {});
+            count(name, began, out.text, out.isError ? { errorCode: out.code ?? "refused", error: out.why } : {}, callId);
             const structured = out.structured && typeof out.structured === "object" && !Array.isArray(out.structured) ? { structuredContent: out.structured } : {};
             return send(result(id, { content: [{ type: "text", text: out.text }], ...structured, ...(out.isError ? { isError: true } : {}) }));
           }
@@ -126,7 +129,7 @@ export function serveMcp({ verbs, version, spec, input = process.stdin, output =
         }
       } catch (err) {
         log(`mcp ${method}: ${err?.stack ?? err}`);
-        if (method === "tools/call") count(NAMES.has(params?.name) ? params.name : "unknown", began, "", { errorCode: "internal" });
+        if (method === "tools/call") count(NAMES.has(params?.name) ? params.name : "unknown", began, "", { errorCode: "internal" }, callId);
         if (!notification) send(result(id, { content: [{ type: "text", text: `Cortad could not answer: ${String(err?.message ?? err)}` }], isError: true }));
       }
     }