cortad 0.3.1-rc.9 → 0.3.2

package/lib/keeping.mjs

@@ -0,0 +1,162 @@
+// What one session keeps out of the run's way and brings up for it: the app's database files and
+// servers, copied before it starts (lib/data.mjs, lib/stores.mjs), and the stores and services it
+// reaches, started when nothing answers there (lib/backing.mjs). Every sentence goes to the terminal
+// and, through lines(), to the run: what trials write into for real first.
+import { createHash } from "node:crypto";
+import { localAddresses, makeBacking, tcpOpen } from "./backing.mjs";
+import { keepData } from "./data.mjs";
+import { bypassedOf, isStorePort, onThisMachine, storeId, storeKeeper, storesOf, unnamedLines } from "./stores.mjs";
+
+// A line that opens with a setting's name keeps its case: "nEXT_PUBLIC_SUPABASE_URL" was printed.
+const lower = (line) => (/^[A-Z][A-Z0-9_]/.test(line) ? line : line.charAt(0).toLowerCase() + line.slice(1));
+// A store at a network address; a socket path, or no host at all, is Postgres's own socket.
+const addressed = (s) => Boolean(s.host) && !s.host.startsWith("/") && Boolean(s.port);
+// One nothing answers at is left for later: trials cannot write into it.
+const isDown = async (s) => addressed(s) && !(await tcpOpen(s.host, s.port));
+// The stores the settings name on this machine, as ports to bring up; a compose image may serve them.
+const localStores = (k) => k.stores.filter((s) => addressed(s) && onThisMachine(s.host)).map((s) => ({ port: s.port, names: s.names, store: true }));
+// The API keeps eight stores that hold Run. Past that, the rest travel as one row, and a yes to that
+// row is a yes to each of them; a row more changes its id, so an old yes no longer covers it.
+const BLOCKED_MAX = 8;
+const overflow = (blocked) => blocked.slice(BLOCKED_MAX - 1);
+// How a service on this machine that answers nothing is named to the API: by its port, never an address.
+const downId = (port) => createHash("sha256").update(`down:${port}`).digest("hex").slice(0, 16);
+const overflowId = (rest) => createHash("sha256").update(rest.map((b) => b.id).join()).digest("hex").slice(0, 16);
+function blockedRows(blocked) {
+  const rows = blocked.map(({ port: _port, ...b }) => ({ ...b, why: b.why.slice(0, 400) }));
+  if (rows.length <= BLOCKED_MAX) return rows;
+  const rest = overflow(rows);
+  const names = [...new Set(rest.flatMap((b) => b.names))].slice(0, 8);
+  return [...rows.slice(0, BLOCKED_MAX - 1), { id: overflowId(rest), names, why: `These ${rest.length} stores hold Run too. ${rest[0].why}`.slice(0, 400) }];
+}
+
+// settings(): the environment the app starts with, the env file each name came from, the app's
+// folder and its source files. launch(plan): a service of the repository started the way the app
+// is. connections(): what the hook saw the app reach. hold(): the run's requests wait from here until
+// the caller has the app on the copies made, since until then it still writes into the originals.
+export function makeKeeping({ root, work, ledgerFile, onPath, say, settings, launch, connections, hold = () => {} }) {
+  let pending = null;
+  let now = null;
+  let backing = null;
+  let backedUp = false;
+  let seen = 0;
+  const told = new Set();
+  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)}`));
+
+  async function keepAll(started) {
+    const { values, from, appDir, sources } = settings();
+    const disk = keepData({ values, from, appDir, root, work, sources, started });
+    const stores = storesOf(disk.values);
+    const keeper = storeKeeper({ ledgerFile, values: disk.values, dirs: [...new Set([appDir, root])] });
+    const got = await keeper.keep(stores, { started, down: isDown });
+    backing ??= makeBacking({ root, appDir, values: disk.values, onPath, ledgerFile, launch, adopt: started });
+    now = { env: { ...disk.env, ...got.env }, risks: got.risks, notes: [...disk.said, ...got.copies], blocked: got.blocked, pass: got.pass, stores, keeper, values: disk.values, started };
+    tell([...now.risks, ...now.notes]);
+    held(now.blocked);
+    return now;
+  }
+  // A read that failed is tried again on the next ask, never handed back as the same failure.
+  const once = (started) => (pending ??= keepAll(started).catch((e) => { pending = null; throw e; }));
+
+  // Brings up what is wanted, copies each store that now answers, and says both.
+  async function bringUp(wants) {
+    const k = await once(true);
+    hold();
+    const up = await backing.up(wants);
+    const got = await k.keeper.keep(k.stores, { started: k.started, down: isDown });
+    Object.assign(k.env, got.env);
+    k.risks.unshift(...got.risks);
+    // Said once: every look brings the same lines back, and status printed one hold four times.
+    k.notes.push(...[...up.lines, ...got.copies].filter((l) => !k.notes.includes(l)));
+    // A service a setting names that answers nothing holds Run until it does; one that answers now
+    // lets go. ai-appointment-setter's only free run played with its knowledge base down.
+    const checked = new Set(wants.map((w) => w.port));
+    const stillDown = new Set(up.down.map((d) => d.port));
+    for (let i = k.blocked.length - 1; i >= 0; i--) if (k.blocked[i].down && checked.has(k.blocked[i].port) && !stillDown.has(k.blocked[i].port)) k.blocked.splice(i, 1);
+    for (const d of up.down) if (!k.blocked.some((b) => b.down && b.port === d.port)) k.blocked.push({ id: downId(d.port), names: d.names, why: d.why, down: true, port: d.port });
+    k.blocked.push(...got.blocked.filter((b) => !k.blocked.some((x) => x.id === b.id)));
+    k.pass.push(...got.pass);
+    const said = [...got.risks, ...up.lines, ...got.copies];
+    tell(said);
+    held(got.blocked);
+    return { changed: said.length > 0 || got.blocked.length > 0, came: up.ports.length > 0, copied: Object.keys(got.env).length > 0 };
+  }
+  // Ports on this machine the hook saw the app reach. A compose image serves only a store's port: a
+  // model server behind a compose file is gigabytes nobody asked for.
+  const reached = (appPort) => connections().filter((c) => onThisMachine(c.host) && c.port !== appPort).map((c) => ({ port: c.port, store: isStorePort(c.port) }));
+
+  return {
+    // The settings the app starts with: the copies it runs against.
+    env: async (started) => (await once(started)).env,
+    // The copies so far, for a service of the repository started beside the app.
+    envNow: () => now?.env ?? {},
+    // What trials write into for real first; the API keeps eight sentences of 400 characters.
+    lines: async (started) => { const k = await once(started); return [...k.risks, ...k.notes].map((l) => l.slice(0, 400)).slice(0, 8); },
+    // The stores off this machine no copy could be made of: each holds Run until the person says yes.
+    blocked: async (started) => blockedRows((await once(started)).blocked),
+    // The hosts a trial's writes may reach: the copies made off this machine, and the hosts and
+    // stores the person said yes to (setup.consent). Before the copies are made, or after the app
+    // was attached to instead, only the hosts.
+    outbound: ({ hosts = [], stores = [] } = {}) => {
+      if (!now) return [...new Set(hosts)];
+      const yes = new Set(stores);
+      const rest = now.blocked.length > BLOCKED_MAX ? overflow(now.blocked) : [];
+      if (rest.length && yes.has(overflowId(rest))) for (const b of rest) yes.add(b.id);
+      return [...new Set([...hosts, ...now.pass, ...now.stores.filter((s) => yes.has(storeId(s)) && !onThisMachine(s.host)).map((s) => String(s.host).toLowerCase())])];
+    },
+    // The app stopped before it answered: each store its settings name and each port it reached that
+    // is down is brought up, once. True when the app is worth starting again.
+    async backUp(appPort) {
+      if (backedUp) return false;
+      backedUp = true;
+      const k = await once(true);
+      const got = await bringUp([...localStores(k), ...reached(appPort)]);
+      return got.came || got.copied;
+    },
+    // The app answers: each store and service its settings name on this machine that nothing
+    // answers at is brought up, since an app that connects on first use starts without them.
+    // `copied` says the app has copies it was not started on.
+    async services(appPort) {
+      const k = await once(true);
+      return bringUp([...localStores(k), ...localAddresses(k.values)].filter((a) => a.port !== appPort));
+    },
+    // What the app reached since the last look. A live store no setting names is said, what is down
+    // is brought up, and `copied` says the app has copies it was not started on.
+    async watch(appPort) {
+      const conns = connections();
+      // A service that held Run and answers now lets go without a reconnect: the person started
+      // Supabase, and the hold stood until they disconnected and connected again.
+      const heldDown = now?.blocked.filter((b) => b.down) ?? [];
+      const cameUp = [];
+      for (const b of heldDown) if (await tcpOpen("127.0.0.1", b.port)) cameUp.push({ port: b.port, names: b.names });
+      if (cameUp.length) { const got = await bringUp(cameUp); if (!pending || conns.length === seen) return { changed: true, copied: got.copied }; }
+      if (!pending || conns.length === seen) return { changed: false, copied: false };
+      seen = conns.length;
+      const k = await pending;
+      const live = [];
+      for (const c of conns) if (!onThisMachine(c.host) || (await tcpOpen(c.host, c.port))) live.push(c);
+      const fresh = unnamedLines(live, k.stores, told);
+      k.risks.push(...fresh);
+      tell(fresh);
+      const bypassed = bypassedOf(live, k.stores, k.blocked);
+      k.blocked.push(...bypassed);
+      held(bypassed);
+      const got = await bringUp(reached(appPort));
+      return { changed: fresh.length > 0 || bypassed.length > 0 || got.changed, copied: got.copied };
+    },
+    // An app attached to instead of started keeps its own connections: its copies are of no use.
+    async forget() {
+      const k = await pending;
+      pending = null;
+      now = null;
+      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(() => {});
+      await backing?.stop().catch(() => {});
+    },
+  };
+}

package/lib/ledger.mjs

@@ -0,0 +1,20 @@
+// What this command made on the person's machine and has not yet undone: a database copied, a
+// service started. Kept in the project's folder under ~/.cortad, so a session that died (a killed
+// terminal, a closed lid) is undone by the next one. Rows name what was made, never an address or
+// a password.
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+const alive = (pid) => { try { process.kill(pid, 0); return true; } catch (e) { return e.code !== "ESRCH"; } };
+
+export function ledger(file) {
+  const read = () => { try { const rows = JSON.parse(readFileSync(file, "utf8")); return Array.isArray(rows) ? rows : []; } catch { return []; } };
+  const write = (rows) => { try { mkdirSync(dirname(file), { recursive: true, mode: 0o700 }); writeFileSync(file, JSON.stringify(rows), { mode: 0o600 }); } catch { /* undone by hand then */ } };
+  const same = (a, b) => a.kind === b.kind && a.key === b.key && a.made === b.made;
+  return {
+    add: (row) => write([...read().filter((r) => !same(r, row)), { ...row, pid: process.pid }]),
+    remove: (row) => write(read().filter((r) => !same(r, row))),
+    // Rows of `kind` whose session has ended.
+    orphans: (kind) => read().filter((r) => r.kind === kind && !alive(r.pid)),
+  };
+}

package/lib/lock.mjs

@@ -3,7 +3,8 @@
 // bubblewrap. Inside it a shell line can read your project and run your tests, and it can write
 // only where your own .gitignore already says files are disposable (caches, build output, coverage)
 // and in temp. It cannot write a tracked file, cannot read your keys or environment files, and on a
-// Mac cannot reach the network beyond this machine. With neither tool present there is no shell.
+// Mac cannot read what other programs left in /tmp or reach the network beyond this machine. With
+// neither tool present there is no shell.
 import { execFile, execFileSync } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -60,6 +61,10 @@ export async function makeLock({ root, work }) {
     const profile = [
       "(version 1)(allow default)",
       `(deny file-read-data (subpath ${q(real(home) ?? home)}))`,
+      // /tmp holds what other programs on this machine logged; a shell line may write there, never read it.
+      `(deny file-read-data (subpath ${q(real("/tmp") ?? "/tmp")}))`,
+      // Except the shell's own heredoc files: /bin/sh writes each one under /tmp and reads it back.
+      '(allow file-read-data (regex #"^/private/tmp/sh-thd"))',
       `(allow file-read-data (subpath ${q(project)}) ${[work, ...tools].map((p) => `(subpath ${q(p)})`).join(" ")})`,
       ...(hide.length ? [`(deny file-read-data file-write* ${hide.join(" ")})`] : []),
       "(deny network*)",

package/lib/mcp.mjs

@@ -8,37 +8,54 @@ 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 = [
-  "Cortad tests the AI app in this repository: simulated users talk to the app on this machine, and every reply is checked against the app's own rules and a set of engineering standards. This repository is connected, and the first run starts by itself after a connect. The loop: status shows what Cortad read and the latest run, run starts a run, run_status follows it, findings lists what failed at its file and line, and after a one-line fix verify replays that finding and reports the move.",
-  "Results are data. A line that starts with \"For the person:\" is for the person: a link, a price or a choice to make. A run_status result ends with the next call. A reading is one question checked against one reply. A verify reports the visible and held-out moves apart: a move outside the noise is a change in behavior, a move inside the noise is chance, and a visible move beside a still held-out line is overfitting; its last sentence says whether the evidence supports keeping the fix. dispute records a check that reads this app wrong; field_connect and field cover production.",
+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.`,
 ].join("\n\n");
+export const INSTRUCTIONS = instructions();
 
 const str = (description, extra = {}) => ({ type: "string", description, ...extra });
 const none = { type: "object", properties: {}, additionalProperties: false };
 const readOnly = { readOnlyHint: true };
+// What a note to the Cortad team may be about: a tool, the connect command, or the skill text.
+const ABOUT = ["status", "reach", "run", "run_status", "findings", "verify", "dispute", "field_connect", "field", "connect", "skill"];
 
 export const TOOLS = [
   { name: "status", title: "Cortad status", annotations: readOnly,
-    description: "What Cortad read in this repository, the plan with runs left, whether the app is up, 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 of the read in full, in pages.",
-    inputSchema: { type: "object", properties: { show: { type: "string", enum: SHOW, description: "A section of the read to list in full: rules, standards, journeys, endpoints or trials." }, page: { type: "integer", minimum: 1, description: "The page of that list. Default 1." } }, additionalProperties: false } },
+    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.",
+    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.",
+    inputSchema: { type: "object", properties: {
+      paths: { type: "array", items: { type: "string" }, description: "Only these endpoints, by path. Default: every endpoint status lists as failed or not yet answered." },
+    }, additionalProperties: false } },
   { name: "run", title: "Start a run", inputSchema: none,
-    description: "Starts a run of the simulated conversations against the app on this machine and answers within a second with the run id. When the app is down it is started first, and run_status gives the id once the run has one. Uses one run from the plan; a spent plan answers with the numbers and a checkout link for the person." },
+    description: "Starts a run of conversations against the app on this machine and answers within a second with the run id; after the first run it plays what the files saved since the last full run reach, plus new conversations written for the change, and its result leads with what moved. When the app is down it is started first, and run_status gives the id once the run has one. Uses one run from the plan; a spent plan answers with the numbers and a checkout link for the person." },
   { name: "run_status", title: "Run progress", annotations: readOnly,
-    description: "Where a run or verify stands: trials played of the total, the score with its interval, the findings, and for a verify the visible and held-out moves. The call holds up to 45 seconds until the count moves, and ends with the next call. With no jobId it follows the run this machine started last, or the latest run.",
+    description: "Where a run or verify stands: conversations played of the total, the findings, what the app's rules and users measured, and for a verify whether the failure is gone, shows less often, stayed or cannot be told yet. The call holds up to 45 seconds until the count moves, and ends with the next call. With no jobId it follows the run this machine started last, or the latest run.",
     inputSchema: { type: "object", properties: { jobId: str("A run or verify id, or the word pending. Omit for the run this machine started last.") }, additionalProperties: false } },
   { name: "findings", title: "Findings", annotations: readOnly,
-    description: "The failures of a run, worst first and grouped by file and line: the question, the replies it held in with the interval, quotes, the trials a verify replays and whether a verify of it can leave the noise. Applies once a run has finished. A long list comes in pages.",
-    inputSchema: { type: "object", properties: { jobId: str("A run id. Omit for the latest."), page: { type: "integer", minimum: 1, description: "The page to read. Default 1." } }, additionalProperties: false } },
+    description: "The failures of a run, worst first and grouped by file and line: the question, the conversations it failed in with the range, the exchange, what a verify replays and how many clean replays would show it gone, then where the conversations ended and how their simulated users fared. With show numbers, every number the run measured: each question and measurement by journey, simulated user and reply, with ranges and the exchange behind the worst group. Once a run has finished, a long list comes in pages.",
+    inputSchema: { type: "object", properties: { jobId: str("A run id. Omit for the latest."), show: { type: "string", enum: ["numbers"], description: "numbers: every number the run measured, in pages." }, page: { type: "integer", minimum: 1, description: "The page to read. Default 1." } }, additionalProperties: false } },
   { name: "verify", title: "Verify a fix",
-    description: "Replays every trial the finding's question was read on, with the same seeds, after a change, and when those read it too few times for a rate, plays up to 12 more trials in the finding's situation: what came back before and now, the move visible and held-out apart (reply by reply, or the question's failure rate on the same trials where the replies cannot be paired), and whether the evidence supports keeping the fix. Answers within a second and says how many new trials it plays; run_status follows it. Uses verify trials from the plan, not a run.",
+    description: "Replays the conversations a finding failed on, word for word, after a change, and again by itself until an exact test says the failure is gone, shows less often, stayed, or cannot tell yet with how many clean replays would decide. Replies refused or failed on the replay are said first; conversations of the same question saved to test the fix are replayed once, and where they disagree with the replays beyond chance the first sentence says so; a crash:N finding replays the requests out when the app stopped. Answers within a second, run_status follows every round, and it uses verify conversations from the plan, not a run.",
     inputSchema: { type: "object", properties: { findingId: str("The finding id from findings."), jobId: str("The run the finding came from. Omit for the latest.") }, required: ["findingId"], additionalProperties: false } },
   { name: "dispute", title: "Dispute a check",
     description: "Records that a finding's check reads this app wrong, with the reason and an optional better wording. The finding and its rate stay as they are; the note goes to the owner.",
     inputSchema: { type: "object", properties: { findingId: str("The finding id."), why: str("One or two sentences: what the check gets wrong about this app.", { maxLength: 500 }), question: str("The wording that fits this app.", { maxLength: 300 }) }, required: ["findingId", "why"], additionalProperties: false } },
+  { name: "feedback", title: "A note to the Cortad team",
+    description: "Sends the Cortad team a note about Cortad itself: a result that read wrong, something you needed that no tool gave, a question a result left open, or what worked. Filing one is part of using Cortad, and the team reads each note. Nothing about the run or its checks changes.",
+    inputSchema: { type: "object", properties: {
+      about: { type: "string", enum: ABOUT, description: "The tool the note is about, connect for the connect command, or skill for the instructions you were handed." },
+      kind: { type: "string", enum: ["problem", "idea", "question", "praise"], description: "problem: wrong or failed; idea: something you needed; question: something a result left open; praise: what worked." },
+      needed: str("What you were trying to do or find out.", { maxLength: 500 }),
+      got: str("What came back instead, in your own words; leave out your users' text and any key.", { maxLength: 1000 }),
+      tried: str("What you did about it: another call, a guess, or asked the person.", { maxLength: 500 }),
+    }, required: ["about", "kind", "needed"], additionalProperties: false } },
   { name: "field_connect", title: "Connect production", inputSchema: none,
-    description: "How production replies reach Cortad, so real conversations are read with the same checks. The ingest key is created by the owner in the browser." },
+    description: "The steps to connect production, to see what real users are doing as it happens and where the AI lets them down. The owner creates the key in the browser." },
   { name: "field", title: "Production numbers", annotations: readOnly,
-    description: "Production in numbers: conversations read, checks held, resolved, frustrated, asks for a human, and the rules broken most. Message text stays out of the answer.",
+    description: "Production in numbers: conversations read, checks passed, resolved, frustrated, asks for a human, and the rules broken most. Message text stays out of the answer.",
     inputSchema: { type: "object", properties: { days: { type: "integer", minimum: 1, maximum: 180, description: "Window in days. Default 30." } }, additionalProperties: false } },
 ];
 const NAMES = new Set(TOOLS.map((t) => t.name));
@@ -47,8 +64,17 @@ const error = (id, code, message) => ({ jsonrpc: "2.0", id, error: { code, messa
 const result = (id, value) => ({ jsonrpc: "2.0", id, result: value });
 
 // Serves until stdin closes. `verbs` is lib/verbs.mjs's object; `version` is the package's.
-export function serveMcp({ verbs, version, input = process.stdin, output = process.stdout, log = () => {} }) {
+// `report` is lib/calls.mjs: handed each tool call once it has answered, and awaited before the exit.
+export function serveMcp({ verbs, version, spec, input = process.stdin, output = process.stdout, log = () => {}, report = async () => {} }) {
   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));
+      sending.add(sent);
+    };
+    let closed = false;
+    const close = () => { if (!closed) { closed = true; void Promise.all(sending).then(() => resolve(0)); } };
     const send = (msg) => output.write(`${JSON.stringify(msg)}\n`);
     let buffer = "";
     input.setEncoding("utf8");
@@ -61,8 +87,8 @@ export function serveMcp({ verbs, version, input = process.stdin, output = proce
         if (line) void handle(line);
       }
     });
-    input.on("end", () => resolve(0));
-    input.on("close", () => resolve(0));
+    input.on("end", close);
+    input.on("close", close);
 
     async function handle(line) {
       let msg;
@@ -70,10 +96,12 @@ export function serveMcp({ verbs, version, input = process.stdin, output = proce
       if (!msg || typeof msg !== "object" || Array.isArray(msg)) { send(error(null, -32600, "invalid request")); return; }
       const { id, method, params } = msg;
       const notification = id === undefined || id === null;
+      const began = Date.now();
       try {
         switch (method) {
           case "initialize":
-            return send(result(id, { protocolVersion: PROTOCOL, capabilities: { tools: {} }, serverInfo: { name: "cortad", version }, instructions: INSTRUCTIONS }));
+            client = { clientName: params?.clientInfo?.name, clientVersion: params?.clientInfo?.version };
+            return send(result(id, { protocolVersion: PROTOCOL, capabilities: { tools: {} }, serverInfo: { name: "cortad", version }, instructions: instructions(spec) }));
           case "notifications/initialized":
           case "notifications/cancelled":
             return;
@@ -84,15 +112,21 @@ export function serveMcp({ verbs, version, input = process.stdin, output = proce
           case "tools/call": {
             const name = params?.name;
             const verb = NAMES.has(name) && Object.hasOwn(verbs, name) ? verbs[name] : null;
-            if (!verb) return send(result(id, { content: [{ type: "text", text: `No tool ${String(name)}.` }], isError: true }));
+            if (!verb) {
+              count("unknown", began, "", { errorCode: "unknown_tool" });
+              return send(result(id, { content: [{ type: "text", text: `No tool ${String(name)}.` }], isError: true }));
+            }
             const out = await verb(params?.arguments ?? {});
-            return send(result(id, { content: [{ type: "text", text: out.text }], ...(out.isError ? { isError: true } : {}) }));
+            count(name, began, out.text, out.isError ? { errorCode: out.code ?? "refused", error: out.why } : {});
+            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 } : {}) }));
           }
           default:
             if (!notification) send(error(id, -32601, `method not found: ${String(method)}`));
         }
       } catch (err) {
         log(`mcp ${method}: ${err?.stack ?? err}`);
+        if (method === "tools/call") count(NAMES.has(params?.name) ? params.name : "unknown", began, "", { errorCode: "internal" });
         if (!notification) send(result(id, { content: [{ type: "text", text: `Cortad could not answer: ${String(err?.message ?? err)}` }], isError: true }));
       }
     }