cortad 0.3.1-rc.18 → 0.3.1-rc.19

package/lib/cli.mjs

@@ -169,7 +169,7 @@ async function appOf(env, project) {
   const token = readToken(project);
   if (!token) return null;
   try {
-    const res = await fetch(`${new URL(env.CORTAD_ORIGIN || "https://cortad.com").origin}/api/mcp/status`, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(15_000) });
+    const res = await fetch(`${new URL(env.CORTAD_ORIGIN || "https://cortad.com").origin}/api/mcp/status?quiet=1`, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(15_000) });
     return res.ok ? (await res.json()).app ?? null : null;
   } catch { return null; }
 }

package/lib/contact-text.mjs

@@ -1,4 +1,4 @@
-import { at, clip, has, num, plural, SIDE } from "./words.mjs";
+import { at, clip, has, num, plural } from "./words.mjs";
 
 // What `status` says between connect and a run: each endpoint a real request proved, with what the
 // hook saw inside those requests; each endpoint the read found that no request has reached; what a
@@ -39,10 +39,11 @@ function rulesLine(r) {
   return `${head}${example ? `, for example ${at(example.path, example.line)} "${clip(example.text, 160)}"` : ""}.`;
 }
 
-const sideOf = (side) => (SIDE[side] ? `, ${SIDE[side]}` : "");
+// Whose it is, as a sentence of its own: "Run waits, on the app's side:" read as a fault of the app's.
+const WHOSE = { ours: "That is on Cortad's side, not your app's.", theirs: "That is in your app." };
 // A door runs do not use yet, or one only Cortad's requests reached, and why.
 function standingLine(v) {
-  if (v.standing === "excluded") return `Runs will not use this endpoint yet${sideOf(v.side)}: ${v.why}`;
+  if (v.standing === "excluded") return `Runs leave this endpoint out: ${v.why}${WHOSE[v.side] ? ` ${WHOSE[v.side]}` : ""}`;
   if (v.standing === "fallback") return `Proven by Cortad's requests alone: ${v.why}`;
   return null;
 }
@@ -53,11 +54,13 @@ const accountsLine = (n) => (!has(n) ? null : n > 1 ? `Conversations are split a
 // Where a trial takes each value the app's own client sets for its model.
 const appFieldLine = (f) => (f.from === "app" ? `"${f.field}" is set by your app${f.path ? ` at ${f.path}` : ""}.` : `"${f.field}" is only in your agent's request.`);
 
-// The last exchange through the door; an ask the proof could not find in the request is left out.
+// The message Cortad took from the last request, so a wrong field shows; the reply is the agent's
+// own, already read, and ten of them were the longest part of ulaim's status. One with no message
+// found keeps a short reply to know it by.
 function sampleLine(s) {
   if (!s?.reply) return null;
-  const cut = s.cut ? ", and the reply stopped before it finished" : "";
-  return s.ask ? `Last request: "${clip(s.ask, 160)}", answered "${clip(s.reply, 240)}"${cut}.` : `Last reply: "${clip(s.reply, 240)}"${cut}.`;
+  const cut = s.cut ? "; the reply stopped before it finished" : "";
+  return s.ask ? `Last message: "${clip(s.ask, 160)}"${cut}.` : `Last reply: "${clip(s.reply, 80)}"${cut}.`;
 }
 
 function doorLines(v) {
@@ -73,7 +76,7 @@ function doorLines(v) {
     v.later ? "Your app takes the message at once and its model answers afterwards; Cortad grades the model's last answer to each message." : null,
     sessionLine(v),
     accountsLine(v.accounts),
-    ...(v.checks ?? []).map((said) => `Cortad's own check on this endpoint: ${said}`),
+    ...(v.checks ?? []).map((said) => `Cortad's test conversation here: ${said}`),
     rulesLine(v.rules),
     v.tools?.length ? `Tools that ran: ${v.tools.join(", ")}.` : null,
     v.passages ? `Passages handed to the model: ${num(v.passages)}.` : null,
@@ -83,28 +86,32 @@ function doorLines(v) {
   return [...lines, ...inner.filter(Boolean).map((l) => `    ${l}`)];
 }
 
-// The time is said at one request at a time, the pace every run starts at; a door the run widens
-// finishes sooner. While the read is still writing trials the counts are what it has so far.
+// 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".
 function readyLine(r) {
   if (!r || !r.trials) return null;
   const soFar = r.reading ? " so far" : "";
-  const fit = has(r.planned) && r.planned > r.trials ? `${num(r.trials)} of the ${plural(r.planned, "trial")} written${soFar}, the ones that fit in one run` : `${plural(r.trials, "trial")}${soFar}`;
-  // The time at the widest the run goes, and at one request at a time when that differs: the run
-  // ramps up only while replies keep pace, and a one-at-a-time app holds it to one.
-  const one = r.atOne;
-  const slower = one && has(one.minutes) && (one.minutes !== r.minutes || one.trials < r.trials);
-  const time = has(r.minutes) && (slower
-    ? `about ${plural(r.minutes, "minute")} if your app answers several requests at once, or up to about ${plural(one.minutes, "minute")}${one.trials < r.trials ? ` and ${plural(one.trials, "trial")}` : ""} if it answers one at a time`
-    : `about ${plural(r.minutes, "minute")}`);
+  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.
   const some = r.pricedOn ? `at least ${usd(r.usd)}, priced on ${num(r.pricedOn.endpoints)} of ${plural(r.pricedOn.of, "endpoint")}` : null;
-  const cost = has(r.usd) && `${some ?? `about ${usd(r.usd)}${has(r.usdHigh) ? ` to ${usd(r.usdHigh)}` : ""}`}${soFar} on your ${r.provider ? `${r.provider} ` : ""}key${r.model ? ` for ${r.model}` : ""}${r.estimated ? ", estimated from the length of the text since your provider sent no token counts" : ""}`;
-  // Follow-ups are played only where something breaks: said apart, never in the count above.
-  const followUps = r.followUps ? `and up to ${plural(r.followUps, "follow-up")} where something breaks` : null;
-  const parts = [fit, followUps, has(r.replies) && `about ${plural(r.replies, "reply", "replies")}`, time, cost].filter(Boolean);
-  const rules = !has(r.rules) ? "" : r.rules === 0 ? " No rules of your own were read from the code, so the run checks replies against generic standards." : ` Replies are checked against the ${plural(r.rules, "rule")} read from your code.`;
-  return `A run on the proven endpoints: ${parts.join(", ")}.${r.reading ? " The read is still adding trials; the run waits for it and plays them all." : ""}${rules}`;
+  // No price is said, as the card says it (guide.ts quoteLine), never left out.
+  const cost = has(r.usd)
+    ? ` It costs ${some ?? `about ${usd(r.usd)}${has(r.usdHigh) ? ` to ${usd(r.usdHigh)}` : ""}`}${soFar} on your ${r.provider ? `${r.provider} ` : ""}key${r.model ? ` for ${r.model}` : ""}${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." : ""}`;
 }
 
 // `data`: what the command did with the app's stores and services, said right under the run it is
@@ -113,11 +120,13 @@ export function contactLines(c, data = []) {
   const said = data.map((s) => `Data: ${s}`);
   if (!c) return said;
   const proven = c.proven ?? [];
-  const lines = proven.length ? [`Endpoints your own requests proved (${num(proven.length)}):`, ...proven.flatMap(doorLines)] : ["No request has reached the app's model yet."];
+  // No request yet is said by the App line and by the next step, not a third time here.
+  const lines = proven.length ? [`Endpoints your own requests proved (${num(proven.length)}):`, ...proven.flatMap(doorLines)] : [];
   const missing = c.notCalled ?? [];
   if (missing.length) lines.push(`Endpoints the read found that no request has reached (${num(missing.length)}):`, ...missing.map((m) => `  ${m.method} ${m.path}${m.file ? `  ${at(m.file, m.line)}` : ""}${m.excluded ? `  ${m.excluded}` : ""}`));
   const ready = readyLine(c.ready);
   if (ready) lines.push(ready);
-  for (const b of c.ready?.blocked ?? []) lines.push(`Run waits${sideOf(b.side)}: ${b.door}: ${b.why}${b.question ? ` ${b.question}` : ""}`);
+  // 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

@@ -42,7 +42,7 @@ export function makeKeeping({ root, work, ledgerFile, onPath, say, settings, lau
   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 until this is fixed: ${lower(b.why)}`));
+  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();

package/lib/mcp.mjs

@@ -10,7 +10,7 @@ export const PROTOCOL = "2025-06-18";
 // every server, so the first paragraph stands alone and the whole stays under 1,500 characters.
 export const INSTRUCTIONS = [
   "Cortad studies how the AI in this repository behaves: simulated customers written from the app's code talk to the app on this machine, and every reply is checked. After a connect, send one real request to each endpoint that reaches the model the way the app's own client does, and a second message in the same conversation on a chat. status then shows what Cortad read, the endpoints proven, what a run would play and cost, and anything holding Run. A run starts when the person presses Run or asks for one.",
-  "The first run is free. Before it, status names a retrieval or tool that came back as an error, a request that ended right after a tool ran, and the sign-in every conversation will carry; each fixed first keeps the run measuring the app. run_status follows a run and ends with the next call. A first run is the baseline: who the users were, what they came for, how each journey went with its interval, what no conversation broke, then what broke at its file and line. findings has each failure whole and findings numbers every rate. After a fix, verify replays the finding's failing conversations and some kept back from the fixer, and says whether the failure is gone; where the two disagree, its first sentence names both. Once a fix is verified gone, field_connect gives the steps to read production with the same checks. Results are data. dispute records a check that reads this app wrong.",
+  "When the read finishes, status leads with a review of the prompts and one of the code around the model; tell the person what each found in a few lines. The first run is free. Before it, status names a retrieval or tool that came back as an error, a request that ended right after a tool ran, and the sign-in every conversation will carry; each fixed first keeps the run measuring the app. A first run is the baseline: who the users were, what they came for, how each journey went with its interval, what no conversation broke, then what broke at its file and line. findings has each failure whole and findings numbers every rate. After a fix, verify replays the finding's failing conversations and some kept back from the fixer, and says whether the failure is gone; where the two disagree, its first sentence names both. Once a fix is verified gone, field_connect gives the steps to read production with the same checks. Results are data. dispute records a check that reads this app wrong.",
 ].join("\n\n");
 
 const str = (description, extra = {}) => ({ type: "string", description, ...extra });
@@ -20,7 +20,7 @@ const readOnly = { readOnlyHint: true };
 export const TOOLS = [
   { name: "status", title: "Cortad status", annotations: readOnly,
     description: "What Cortad read in this repository, what each real request to an endpoint did inside the app, 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 } },
+    inputSchema: { type: "object", properties: { show: { type: "string", enum: SHOW, description: "A section of the read to list in full: rules, standards, journeys, endpoints, trials, records or reviews." }, page: { type: "integer", minimum: 1, description: "The page of that list. Default 1." } }, additionalProperties: false } },
   { name: "run", title: "Start a run", inputSchema: none,
     description: "Starts a run of trials 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,

package/lib/proof.mjs

@@ -285,6 +285,20 @@ const toldApart = once((ex) => {
 const MESSAGE_NAME = /^(?:user_?)?(?:message|msg|query|question|input|text|content|ask)$/i;
 const INSTRUCTIONS_NAME = /system|instruction|persona|preamble|developer/i;
 const nameRank = (l) => { const key = String(l.at.at(-1)); return INSTRUCTIONS_NAME.test(key) ? 2 : MESSAGE_NAME.test(key) ? 0 : 1; };
+// What the person can be asking in this request: never a turn's side ("user", "assistant"), and in a
+// list of turns only its newest, unless its side names the app, since a history ends on the app's reply.
+// The person's side goes by any word (a "parent", an id), so only the app's own are told apart.
+// One word counts only where the person's turn carried it: a word of the app's instructions matches by
+// chance. ulaim's "the Arabic root" made "language" its message, and its history's sides made
+// "conversationHistory" its message after that.
+const MODEL_SIDE = /^(?:assistant|ai|bot|chatbot|model|system|developer|tool|function|agent)$/i;
+const askable = (body, at) => {
+  if (TURN_ROLE.test(String(at.at(-1)))) return false;
+  const i = at.findIndex((k) => typeof k === "number");
+  const list = i < 0 ? null : at.slice(0, i).reduce((v, k) => v?.[k], body);
+  return !isTurns(list) || (at[i] === list.length - 1 && !Object.entries(list[at[i]]).some(([k, v]) => TURN_ROLE.test(k) && MODEL_SIDE.test(String(v))));
+};
+const words = (v) => /\s/.test(v) || (v.match(/[\p{L}\p{N}]/gu) ?? []).length >= TOLD_MIN;
 
 // The body leaves the app's own client set for its model: words the model was given as a whole
 // instruction message or only inside one, while another field reached it as the person's turn, and a
@@ -315,7 +329,9 @@ function askOf(exchanges) {
     const prompt = promptOf(ex);
     const body = bodyOf(ex);
     if (!prompt || !body) continue;
-    const found = leaves(body).map((l) => ({ ...l, v: norm(l.value) })).filter((l) => l.v.length >= 3 && /[a-z\u00c0-\uffff]/.test(l.v) && prompt.includes(l.v));
+    const { person } = toldApart(ex);
+    const found = leaves(body).map((l) => ({ ...l, v: norm(l.value) })).filter((l) => l.v.length >= 3 && /[a-z\u00c0-\uffff]/.test(l.v) && askable(body, l.at) && prompt.includes(l.v)
+      && (words(l.v) || person.some((t) => t.includes(l.v))));
     for (const l of appLeaves(ex, found)) app.add(fieldOf(l.at));
     for (const l of found) {
       const field = fieldOf(l.at);
@@ -339,7 +355,7 @@ function askIn(ex, ask) {
   const body = bodyOf(ex);
   if (!ask || !body) return "";
   const prompt = promptOf(ex);
-  return leaves(body).filter((l) => fieldOf(l.at) === ask.field && (!ask.list || prompt.includes(norm(l.value)))).at(-1)?.value ?? "";
+  return leaves(body).filter((l) => fieldOf(l.at) === ask.field && askable(body, l.at) && (!ask.list || prompt.includes(norm(l.value)))).at(-1)?.value ?? "";
 }
 
 // ---- the session

package/lib/pyhook/sitecustomize.py

@@ -1153,6 +1153,30 @@ def _install():
         except (TypeError, ValueError):
             return ""
 
+    # A model request kept whole when it fits; a longer one keeps its shape and every value short
+    # enough to be a turn, its longest texts cut in their middle (lib/wire.cjs fitted).
+    def fitted(body):
+        whole = text(body, reply_max)
+        if len(whole) <= limit:
+            return whole
+        try:
+            parsed = json.loads(whole)
+        except ValueError:
+            parsed = None
+        cap = limit // 2
+        while isinstance(parsed, (dict, list)) and cap >= 256:
+            def cut(v):
+                if isinstance(v, str):
+                    return v if len(v) <= cap else v[:cap // 2] + " [...] " + v[-(cap // 2):]
+                if isinstance(v, list):
+                    return [cut(x) for x in v]
+                return {k: cut(x) for k, x in v.items()} if isinstance(v, dict) else v
+            out = json.dumps(cut(parsed), ensure_ascii=False)
+            if len(out) <= limit:
+                return out
+            cap //= 2
+        return whole[:limit]
+
     # An exchange is kept when the request makes its first model call, for the first few requests per
     # route, and written once the app has answered. Model calls and tool rows carry the request's id
     # whether kept or not; the command joins them to the exchange it has.
@@ -1202,7 +1226,7 @@ def _install():
                 per_route[key] = n + 1
                 req["kept"] = True
         if req["kept"] and len(req["sent"]) < sent_max:
-            req["sent"].append(text(body))
+            req["sent"].append(fitted(body))
         return req
 
     def noted(url, sent):

package/lib/read-text.mjs

@@ -6,7 +6,10 @@ import { at, clip, has, num, pack, pageOf, plural, SIDE } from "./words.mjs";
 // The full list comes back from GET /mcp/status?show=<name>: read.rules.all, read.machine.misses
 // complete with read.machine.mets, read.journeys.all, read.doors.all, read.trials.all. Where the API
 // has not sent it, what it did send is listed with "n of N listed".
-export const SHOW = ["rules", "standards", "journeys", "endpoints", "trials"];
+// `records` lists the plain status's own `read.records`: the server sends them with every status.
+// `reviews` are the two reviews the read leaves, of the prompts and of the code around the model:
+// status hands them over once as news, and this lists them again.
+export const SHOW = ["rules", "standards", "journeys", "endpoints", "trials", "records", "reviews"];
 
 const rulesHead = (rules) => {
   const files = Array.isArray(rules.files) ? rules.files.length : rules.files;
@@ -16,13 +19,17 @@ const rulesHead = (rules) => {
 const measuredOf = (m) => (m === null ? "; asked of no reply yet" : m ? `; asked of ${plural(m.asked, "reply", "replies")}, passed in ${num(m.held)}${m.asked > m.held ? `, broke in ${num(m.asked - m.held)}` : ""}` : "");
 const ruleLine = (e) => `  ${e.path ? `${at(e.path, e.line)}  ` : ""}"${clip(e.text, 300)}"${"measured" in e ? measuredOf(e.measured) : ""}`;
 const headOf = (label, parts) => (parts.some(Boolean) ? `${label}: ${parts.filter(Boolean).join(", ")}.` : `${label}:`);
-const standardsHead = (m) => headOf("Engineering standards", [has(m.decided) && `${num(m.decided)} decided`, has(m.met) && `${num(m.met)} met`, has(m.missed) && `${num(m.missed)} missed${has(m.problems) ? `, from ${plural(m.problems, "problem")}` : ""}`]);
+// "28 decided, 28 met, 0 missed, from 0 problems" was four counts for one fact.
+// A review that decided nothing (it failed, or no standard applied) makes no claim: "meets all 0".
+const standardsHead = (m) => (!has(m.met) || !(m.met + (m.missed ?? 0)) ? "Engineering standards:"
+  : m.missed ? `Engineering standards: your code misses ${num(m.missed)} of the ${num(m.decided ?? m.met + m.missed)} Cortad checks${has(m.problems) ? `, through ${plural(m.problems, "problem")}` : ""}.`
+    : `Engineering standards: your code meets all ${num(m.met)} that Cortad checks.`);
 const decided = (x) => (x.decidedBy ? ` (decided by ${x.decidedBy === "code" ? "code" : "a model"})` : "");
 // A miss is one problem with the standards it fails beneath it; an older API sent one standard a row.
 // A problem their own documents waive says so, with the line; the server lists it last.
 const designed = (x) => (x.byDesign ? `\n    By design here, per ${x.byDesign.at}: "${clip(x.byDesign.said, 200)}"` : "");
 const standardLine = (x) => Array.isArray(x.standards)
-  ? `  ${x.path ? `${at(x.path, x.line)}  ` : ""}${clip(x.problem, 240)}${decided(x)}\n    ${x.standards.length === 1 ? "Fails" : `Fails ${num(x.standards.length)}`}: ${x.standards.join("; ")}${designed(x)}`
+  ? `  ${x.path ? `${at(x.path, x.line)}  ` : ""}${clip(x.problem, 240)}${decided(x)}${x.fix ? `\n    ${clip(x.fix, 300)}` : ""}\n    ${x.standards.length === 1 ? "Fails" : `Fails ${num(x.standards.length)}`}: ${x.standards.join("; ")}${designed(x)}`
   : `  ${x.path ? `${at(x.path, x.line)}  ` : ""}${x.standard}${x.detail ? `: ${clip(x.detail, 240)}` : ""}${decided(x)}`;
 // Which trials can be played is decided when a run knocks: a read that said "21 playable, none held
 // back" was followed by a run that held 28 back, and three agents called the counts contradictory.
@@ -32,40 +39,43 @@ const named = (label, group, max = 12) => {
   if (!group) return null;
   const names = group.names ?? [];
   const more = (group.count ?? names.length) - Math.min(names.length, max);
-  const list = names.slice(0, max).join(", ");
-  return `${label} (${num(group.count ?? names.length)})${list ? `: ${list}${more > 0 ? `, and ${more} more` : ""}` : ""}.`;
+  // A name may hold commas ("A student, Grade 10 Sem 2 (Jordan), English"): one name ends at a semicolon.
+  const list = names.slice(0, max).join("; ");
+  return `${label} (${num(group.count ?? names.length)})${list ? `: ${list}${more > 0 ? `; and ${more} more` : ""}` : ""}.`;
 };
 // "Journeys (6):" when every one is here, "Journeys (6), 4 listed:" when not.
 const counted = (label, count, n) => `${label} (${num(count ?? n)})${has(count) && n < count ? `, ${num(n)} listed` : ""}:`;
 
 // The records the app already holds, read from its own data files, that a trial may name: an agent
 // that sees a trial ask about SO20260810001 can tell it is a real order, not an invented one.
-const recordsLine = (records) => {
-  const collections = (records?.collections ?? []).filter((c) => c?.name && c.examples?.length);
-  if (!collections.length) return null;
-  return `Records the trials can name: ${collections.map((c) => `${c.name} (${c.examples.slice(0, 3).map((e) => clip(e, 40)).join(", ")})`).join(", ")}.`;
-};
+// Listed with show records, never in the walkthrough: ulaim's was 45 ids in one line.
+const recordLines = (records) => (records?.collections ?? []).filter((c) => c?.name && c.examples?.length)
+  .map((c) => `  ${c.name}: ${c.examples.slice(0, 3).map((e) => clip(e, 40)).join(", ")}`);
 
 // The walkthrough, in the order the person is walked through it.
+// The endpoints are listed above it, proven or not reached, and the questions are the rules and
+// standards counted again: neither is said here, and status with show lists every section in full.
 export function readLines(r) {
   const lines = ["What Cortad read:"];
   if (r.rules) {
     const examples = (r.rules.examples ?? []).slice(0, 3);
-    lines.push(`${rulesHead(r.rules)}${examples.length ? ` ${examples.length} of them:` : ""}`, ...examples.map(ruleLine));
+    // "Asked of no reply yet" on each rule before any run is a fact about no run.
+    const ran = has(r.rules.measured);
+    lines.push(`${rulesHead(r.rules)}${examples.length ? ` ${examples.length} of them:` : ""}`, ...examples.map((e) => ruleLine(ran ? e : { text: e.text, path: e.path, line: e.line })));
   }
-  for (const line of [named("Journeys", r.journeys), named("Simulated users", r.profiles), named("Endpoints", r.doors), recordsLine(r.records)]) if (line) lines.push(line);
+  for (const line of [named("Journeys", r.journeys), named("Simulated users", r.profiles)]) if (line) lines.push(line);
   const m = r.machine;
-  if (m) {
+  if (m && (m.met || m.missed || (m.misses ?? []).length)) {
     const misses = m.misses ?? [];
     // "3 missed" was read off a list of three under a head that said thirteen: the list says it is a part.
     lines.push(standardsHead(m), ...(misses.length > 3 && has(m.missed) && m.missed > 3 ? [`  3 of the ${num(m.missed)} missed:`] : []), ...misses.slice(0, 3).map(standardLine));
     const more = (m.problems ?? misses.length) - Math.min(misses.length, 3);
     if (more > 0) lines.push(`  and ${plural(more, "more problem")}; status with show standards lists them all.`);
   }
-  const q = r.questions;
-  if (q) lines.push(`Questions: ${num(q.total)}${has(q.everywhere) ? `; ${num(q.everywhere)} asked in every conversation` : ""}${has(q.placed) ? `, ${num(q.placed)} placed in the situations they fit` : ""}.`);
-  const t = r.trials;
-  if (t) lines.push(trialsHead(t), ...(t.held ?? []).map((h) => `  ${h.surface}: ${plural(h.n, "trial")} set aside${heldWhy(h)}`));
+  if (r.reviews?.lines.length) lines.push("The reviews of your prompts and of the code around your model are listed whole by status with show reviews.");
+  // What a run plays is the quote's to say; here only conversations set aside, and why.
+  const held = r.trials?.held ?? [];
+  if (held.length) lines.push("Conversations set aside:", ...held.map((h) => `  ${h.surface}: ${plural(h.n, "conversation")}${heldWhy(h)}`));
   return lines;
 }
 
@@ -100,6 +110,12 @@ function sectionOf(r, show) {
       const all = r.doors?.all ?? (r.doors?.names ?? []).map((name) => ({ name }));
       return { head: counted("Endpoints", r.doors?.count, all.length), lines: all.map((e) => `  ${e.name}${e.path ? `: ${[e.method, e.path].filter(Boolean).join(" ")}` : ""}`), continued: "Endpoints, continued." };
     }
+    case "records":
+      return recordLines(r.records).length
+        ? { head: "Records the trials can name, three of each:", lines: recordLines(r.records), continued: "Records, continued." }
+        : { head: "The read found no records a trial can name.", lines: [], continued: "" };
+    case "reviews":
+      return { head: "The reviews of your prompts and of the code around your model:", lines: r.reviews?.lines.length ? r.reviews.lines : [r.complete === false ? "Your code is still being read; the reviews come when that is done." : r.reviews ? "The read left no review of this app's prompts or code." : "This status carries no reviews."], continued: "The reviews, continued." };
     case "trials":
     default: {
       const t = r.trials ?? {};

package/lib/stores.mjs

@@ -228,22 +228,22 @@ const HELD = {
   "neon-key": (s) => ["there is no NEON_API_KEY in its settings to make a branch with", `Set NEON_API_KEY, or point ${s.names[0]} at a database on this machine`],
   neon: (s) => ["Neon did not make a branch of it", `Check NEON_API_KEY, or point ${s.names[0]} at a database on this machine`],
   supabase: (s) => ["a local Supabase needs supabase/config.toml, Docker and the supabase command", `Add them, or point ${s.names[0]} at a local Supabase`],
-  engine: (s) => [`a hosted ${ENGINE[s.engine]} is not one we copy`, `Point ${s.names[0]} at a server on this machine`],
+  engine: (s) => [`Cortad cannot copy a hosted ${ENGINE[s.engine]}`, `Point ${s.names[0]} at a ${ENGINE[s.engine]} on this machine`],
   parts: (s) => ["its settings name it in parts, which cannot be pointed at a copy", `Put its whole address in one setting, or point ${s.names[0]} at a database on this machine`],
   "no-migrations": (s) => ["no migrations were found to build a copy on this machine from", `Point ${s.names[0]} at a database on this machine`],
   "no-local": (s) => ["no Postgres on this machine let us make a database to build a copy in", "Start Postgres on this machine"],
   migrations: (s, tool) => [`its ${tool} migrations did not run against a copy on this machine`, `Run them against a local database once by hand, or point ${s.names[0]} at one`],
-  started: () => ["your app was already running when this command started, so it cannot be pointed at a copy", "Stop it and run the command again"],
+  started: () => ["your app was already running when this command started", "Stop your app"],
   bypassed: () => ["your app reached it anyway, since it loads its settings file over the settings it was started with", "Load that file without overriding what is already set"],
   other: (s) => ["the copy did not go through", `Point ${s.names[0]} at a database on this machine`],
 };
-// The other way out is the owner's yes on the card in the browser, which lets trials write into it as
-// it is: an agent told only to move the store spent ten minutes on a local Qdrant the card had offered
-// to do without (ulaim, 2026-10-01).
+// The fact and the way to keep the store out of the run, read by the person on the card and by their
+// agent in status. The other way, the owner's yes, is each surface's own to offer: the card as its
+// button, status in the sentence after this one (src/local/contact.ts heldLine). Written in here, the
+// card told the owner, on the card, that "the owner can say yes to it on the card in the browser".
 const heldWhy = (s, why, tool) => {
   const [reason, fix] = (HELD[why] ?? HELD.other)(s, tool);
-  const yes = why === "started" ? "" : " Or the owner can say yes to it on the card in the browser, and trials write into it as it is.";
-  return `Trials would write into the ${whatOf(s)} that ${listed(s.names)} ${s.names.length === 1 ? "names" : "name"}, on a server off this machine, and ${reason}. ${fix}, then run the command again.${yes}`;
+  return `${listed(s.names)} ${s.names.length === 1 ? "points" : "point"} at ${s.engine === "redis" || s.db ? "the" : "a"} ${whatOf(s)} off this machine, and ${reason}, so the run would write into it as it is. ${fix}, then run the connect command again.`;
 };
 const hostedKept = (s, got) => (got.how === "neon"
   ? `Your app runs against a Neon branch of its ${whatOf(s)}, made for this session through ${listed(s.names)}; the original is not touched, and the branch is deleted when this command ends.`

package/lib/text.mjs

@@ -36,14 +36,17 @@ export function statusText(d) {
   if (plan) lines.push(plan);
   lines.push(...appLines(d));
   lines.push(...contactLines(d.contact, d.app?.data));
-  if (d.read?.complete === false) lines.push("The read of your repository is still running; the lists below fill in as it finishes.");
-  if (d.read) lines.push(...readLines(d.read));
-  if (d.run === null) lines.push("No run yet.");
-  else if (d.run) lines.push(...runLines(d.run, "latest "));
+  // While the read runs its lists are zeros ("Journeys (0)", "Questions: 0; 0 asked..."): it is said
+  // once, and the lists come when it lands (the server's news says so).
+  // The quote says it when it is said (it names the read with what the run does about it).
+  if (d.read?.complete === false) { if (!d.contact?.ready?.reading || !d.contact.ready.trials) lines.push("Your code is still being read."); }
+  else if (d.read) lines.push(...readLines(d.read));
+  if (d.run) lines.push(...runLines(d.run, "latest "));
   // Trials the read wrote after this run chose its own: the one count that is not the run's.
   const since = (d.read?.trials?.written ?? 0) - (d.run?.trials?.written ?? Infinity);
   if (since > 0 && d.run?.kind !== "verify") lines.push(`${plural(since, "more trial")} written since this run; the next run chooses from them too.`);
-  if (d.field) lines.push(`Production: ${d.field.connected ? "connected" : "not connected"}.`);
+  // Production comes up after the first run (skill: The second run and production).
+  if (d.field && d.run) lines.push(`Production: ${d.field.connected ? "connected" : "not connected"}.`);
   if (d.next) lines.push(d.next);
   if (d.links?.lab && (d.read || d.run)) lines.push(`For the person: ${d.links.lab} shows this in the browser.`);
   if (d.run && !finished(d.run)) lines.push(`next: run_status ${d.run.jobId}`);
@@ -103,7 +106,7 @@ function promiseLines(p) {
 
 const promiseLine = (d) => `${upper(`${num(d.promises.held)} of the ${plural(d.promises.decided, "trial")}`)} that asked your app's own promises kept every one.`;
 
-const haltLine = (h) => `${h.side === "ours" ? `Stopped ${SIDE.ours}` : "Your app stopped answering"} after ${plural(h.after, "turn")}${h.why ? `: ${clip(h.why, 240)}` : ""}. The numbers cover the turns before that.`;
+const haltLine = (h) => `${h.side === "ours" ? `Stopped ${SIDE.ours}` : "Your app stopped answering"} after ${plural(h.after, "reply", "replies")}${h.why ? `: ${clip(h.why, 240)}` : ""}. The numbers cover the replies before that.`;
 // The pace a slow app was played at, and the replies our own wait cut off: both said as ours. A
 // verify says the second among the replays it could not read.
 const waitLines = (d) => [d.pace?.said, d.kind === "verify" ? null : d.waited?.said].filter(Boolean);
@@ -182,8 +185,9 @@ function trialsLine(d) {
 // before the first turn has no turn to name, and a reason written as a sentence keeps one full stop.
 function stoppedLine(d) {
   const s = d.stopped;
-  // A stop before the trials, on the endpoints' first conversations, names each one instead of a turn.
-  const turn = s.after > 0 && !s.first ? ` at turn ${s.after}` : "";
+  // A stop before the trials, on the endpoints' first conversations, names each one instead of a count.
+  // `after` counts the replies of the whole run, never one conversation's turn.
+  const turn = s.after > 0 && !s.first ? ` after ${plural(s.after, "reply", "replies")}` : "";
   const why = String(s.why).replace(/\.$/, "");
   const fix = s.fix ? ` ${s.fix}` : "";
   if (d.of && d.played < d.of) return `Stopped at ${num(d.played)} of ${plural(d.of, "trial")}${SIDE[s.side] ? `, ${SIDE[s.side]}` : ""}: ${why}${turn}.${fix}`;
@@ -325,7 +329,7 @@ export function linesOf(d) {
 export const findingsText = (d, page = 1) => pageOf(findingsPages(d), page, (n) => `findings with page ${n}`);
 
 function findingsHead(d) {
-  if (!d.runId) return "No run has finished on this repository yet.";
+  if (!d.runId) return d.why ?? "No run has finished on this repository yet.";
   const settled = (d.findings ?? []).filter((f) => f.trials && !f.unsettled).length;
   const lines = [`Run ${d.runId}: ${plural(d.findings?.length ?? 0, "finding")}${settled ? `, ${num(settled)} settled` : ""}.`];
   const cost = costSaid(d);
@@ -341,7 +345,8 @@ function findingsTail(d) {
   if (d.halted) lines.push(haltLine(d.halted));
   lines.push(...waitLines(d));
   if (d.baseRunId) lines.push(`Compared with run ${d.baseRunId}.`);
-  for (const s of [d.read, d.heldBack, d.findings?.length ? null : d.why]) if (s) lines.push(s);
+  // With no run to read, the head already said why.
+  for (const s of [d.read, d.heldBack, d.findings?.length || !d.runId ? null : d.why]) if (s) lines.push(s);
   // A finding in a situation the run keeps back: what failed and where, so the rule can be fixed;
   // its inputs and trials stay unseen, and verify replays it all the same.
   for (const k of d.keptBack ?? []) lines.push(`Kept back ${k.id}: "${clip(k.asks, 160)}"${k.file ? ` at ${at(k.file, k.line)}` : ""}, ${k.trials ? `failed in ${num(k.trials.failed)} of ${plural(k.trials.of, "trial")}` : `passed in ${kn(k.rate)}${has(k.reply) ? ` at reply ${num(k.reply)}` : ""}`}${k.quote ? `; the reply said "${clip(k.quote, 120)}"` : ""}. Its inputs are not shown; verify ${k.id} replays them.`);

package/lib/verbs.mjs

@@ -58,7 +58,9 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   // With show, one section of the read in full, paged; a name that is not a section is the plain status.
   const status = async ({ show, page } = {}) => {
     const section = SHOW.includes(show) ? show : null;
-    const res = await call("GET", `/mcp/status${section ? `?show=${section}` : ""}`);
+    // The plain status is the one read that prints the server's news, and says so; a section prints
+    // none, so it takes none.
+    const res = await call("GET", `/mcp/status${section ? `?show=${section}&quiet=1` : "?news=1"}`);
     if (!res.ok) return failed(res);
     // Status says a finished run itself, so the line kept to tell the agent of it is not said again.
     if (finished(res.data?.run) && res.data.run.jobId) heard(res.data.run.jobId);
@@ -70,7 +72,7 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   // The files saved since the run the next one is compared with (status `baseline`), which scope a
   // run after a change on Cortad's side. None when this machine cannot say: the run replays everything.
   const changeOf = async (seen) => {
-    const base = (seen ?? (await call("GET", "/mcp/status")).data)?.baseline;
+    const base = (seen ?? (await call("GET", "/mcp/status?quiet=1")).data)?.baseline;
     const files = base?.jobId ? code?.saved?.(base.startedAt) : null;
     return files && files.length <= MOST_CHANGED ? { since: base.jobId, files } : null;
   };
@@ -99,7 +101,7 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   const start = async (args, kind) => {
     const here = runner();
     if (here?.state === "failed") return { text: notStartedText(here), data: { app: here }, isError: true };
-    const before = await call("GET", "/mcp/status");
+    const before = await call("GET", "/mcp/status?quiet=1");
     if (!before.ok) return failed(before);
     if (here?.state === "up" && before.data.app?.state === "ready-to-test") {
       const idle = !before.data.run || finished(before.data.run);
@@ -121,7 +123,7 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   // With no id: the run this machine is still starting, held here until it has an id, or else the
   // latest run on the server.
   const resolve = async (until) => {
-    const latest = await call("GET", "/mcp/status");
+    const latest = await call("GET", "/mcp/status?quiet=1");
     if (!latest.ok) return failed(latest);
     const newest = latest.data.run?.jobId ?? null;
     let p = pending.read();
@@ -217,7 +219,7 @@ export function makeVerbs({ api, token, runner = () => null, fetchImpl = fetch,
   // `status --changed`: the files Cortad cites that changed since the latest run started, with the
   // findings at them. Empty when there is nothing to say, or nothing could be asked.
   const changed = async () => {
-    const [s, f] = await Promise.all([call("GET", "/mcp/status"), gather()]);
+    const [s, f] = await Promise.all([call("GET", "/mcp/status?quiet=1"), gather()]);
     const r = s.ok ? s.data?.run : null;
     if (!r) return { text: "" };
     const kept = pending.read();

package/lib/wire.cjs

@@ -577,6 +577,19 @@ const decoded = (buf, encoding) => {
   } catch { return ""; }
 };
 const parse = (text) => { try { return JSON.parse(text); } catch { return null; } };
+// A model request is kept whole when it fits. A longer one keeps its shape and every value short
+// enough to be a turn, its longest texts cut in their middle: every provider puts the newest turn
+// last, and cutting the body's end kept ulaim's 25,000-token prompt without the person's words.
+// ponytail: a turn longer than the cap that fits is cut too; keep turns whole if one is ever lost.
+const fitted = (text) => {
+  if (text.length <= MAX) return text;
+  const body = parse(text);
+  for (let cap = MAX / 2; body && typeof body === "object" && cap >= 256; cap /= 2) {
+    const out = JSON.stringify(body, (_, v) => (typeof v === "string" && v.length > cap ? `${v.slice(0, cap / 2)} [...] ${v.slice(-cap / 2)}` : v));
+    if (out.length <= MAX) return out;
+  }
+  return text.slice(0, MAX);
+};
 const n = (v) => (Number.isInteger(v) && v > 0 ? v : 0);
 // The shapes the providers answer in. promptTokens is the whole input, cache included, so totals add up.
 const tokensOf = (u) => {
@@ -735,7 +748,7 @@ function makeRecorder({ row, rulesFile, onTurn = () => {}, onEnded = () => {} })
       const n = perRoute.get(key) || 0;
       if (n < max && (n || perRoute.size < ROUTES_KEPT)) { perRoute.set(key, n + 1); ctx.kept = true; }
     }
-    if (ctx.kept && ctx.sent.length < SENT_MAX) ctx.sent.push(String(sent || "").slice(0, MAX));
+    if (ctx.kept && ctx.sent.length < SENT_MAX) ctx.sent.push(fitted(String(sent || "")));
     return ctx;
   };
   const rowOf = (ctx) => {
@@ -818,5 +831,5 @@ function makeRecorder({ row, rulesFile, onTurn = () => {}, onEnded = () => {} })
 module.exports = {
   MAX, REPLY_MAX, EMBEDDING, TOOL_TEXT, MODEL_HOST,
   scrubbed, list, clipped, argsText, turnOf, toolText, isModelCall, isRetrieval, passagesFrom, decoded, cookieNames,
-  makeRecorder,
+  fitted, makeRecorder,
 };

package/local.mjs

@@ -1371,7 +1371,7 @@ const IDLE_MS = 10 * 60_000;
 if (argv.includes("--until-idle") && stored) {
   let idleSince = Date.now();
   setInterval(async () => {
-    const res = await call("GET", "/mcp/status", undefined, { headers: { authorization: `Bearer ${stored}` } }).catch(() => null);
+    const res = await call("GET", "/mcp/status?quiet=1", undefined, { headers: { authorization: `Bearer ${stored}` } }).catch(() => null);
     if (res?.ok && res.data?.run && !finished(res.data.run)) idleSince = Date.now();
     else if (Date.now() - idleSince > IDLE_MS) { say("no run for ten minutes, leaving"); await close(0); }
   }, 60_000).unref();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortad",
-  "version": "0.3.1-rc.18",
+  "version": "0.3.1-rc.19",
   "description": "Connects the AI app on your machine to Cortad for test conversations, and gives your coding agent the MCP and skill to run them. No dependencies.",
   "bin": {
     "cortad": "local.mjs"

package/skill/SKILL.md

@@ -26,15 +26,20 @@ The connect command ends with "Go back to the browser". The person is waiting on
 1. The moment the command says "Go back to the browser", tell the person: connected, the app is up on which port (or did not start, and what the command names), and that you are now sending it one real request per endpoint. If the app did not start, say what you would change and change it only if they say so; the command starts the app again by itself after a save.
 2. Send one real request to each endpoint that reaches the model, the way the app's own client does: its route, its body, its sign-in. On a chat, send a second message in the same conversation. When `status` asks for a request signed in as another customer, send it: each customer you sign in as becomes an account of its own in the run.
 3. A reply that is an error, or a `Problem` line in `status` (a provider refusing, a retrieval with no answer, a tool that failed), is the app's own state, not yours to repair in silence. Say it in two lines: what failed, at which file and line, whose side it is on. Then ask whether they want it fixed first or the run as the app stands. Two minutes of reading for the cause at most, then say what you have.
-4. `status` shows what Cortad read (rules, journeys, simulated users, endpoints, standards) and each endpoint your requests reached with what it did inside the app: the model and how many calls a request made, the seconds a reply took, which of the rules read from the code the prompts carried, the tools that ran, the passages handed to the model, and problems a line of code decides, at their file and line. Endpoints the read found that no request reached are listed apart. The line `A run on the proven endpoints:` says how many conversations, about how long and about what it costs on the app's own key; any `Run waits` line says whose side it is on, and a hold on a hosted store is lifted by the person's yes on the card in the browser, not by you moving the store.
-5. The first run is free. Before it, read `status` for what would make the run measure the setup instead of the app:
+4. `status` shows what Cortad read (rules, journeys, simulated users, endpoints, standards) and each endpoint your requests reached with what it did inside the app: the model and how many calls a request made, the seconds a reply took, which of the rules read from the code the prompts carried, the tools that ran, the passages handed to the model, and problems a line of code decides, at their file and line. Endpoints the read found that no request reached are listed apart. Those lines are for you. The lines that start with `For the person:` are for them: what a run would play, take and cost, and a decision only they can make, such as a store off this machine the run would write into. They allow that with one press on the card, which also starts the run, or keep the store out by pointing its setting at one on this machine; you cannot give that yes, `run` is refused until they do, and you move the store only if they ask.
+5. When the read of the code finishes, `status` leads with two reviews under `New since your last call`: one of the instructions in the app's prompts, one of the code around its model, each problem at its file and line with what to change. `status` with show `reviews` lists them again. The person hears them from you without asking; change nothing they name until the person says so.
+6. The first run is free. Before it, read `status` for what would make the run measure the setup instead of the app:
    - a service down: a `Problem` line where a retrieval got no answer, or a tool came back as an error;
    - a request that ended on a tool call: `The request ended right after ... ran: no model call came after it`, which every conversation on that endpoint would repeat;
    - the sign-in: `Every trial sends the sign-in your agent's own request carried, so all trials act as one account`, or a request your app answered 401 or 403.
    Say what applies and what you would do about it; fix it when they agree, send the request again, and read `status` again. A run that measured nothing is not counted against the plan.
-6. Then tell the person, in your own words: which endpoints answered and what `status` shows about them, and that Run is open in the browser or that you can start it. Stop there; the run is theirs to start. When it ends you are told, on your next prompt or edit, what it found and the call to make, if `npx {{cortad}} stick` has been run in this repository (below); say that in one line, and offer to run it.
+7. Then tell the person three things, a sentence or two each, and nothing else:
+   - what Cortad found: how many of their endpoints answered, the rules, journeys and kinds of users under `What Cortad read`, and what the two reviews found: how many problems each, and the one or two that matter most at their file and line;
+   - the decision that is theirs, from the `For the person:` line that asks one, if there is one;
+   - what the run will play, take and cost, from the `For the person:` line that starts `a run plays`, whether it is their free run, any endpoint a `Runs leave this endpoint out` line names with whose side that is, and the link to the card.
+   Models, reply times, fields, passages, messages and the endpoints no request reached stay with you unless they ask. Say it once, then stop: the run is theirs to start, from the card or by asking you. If they say they pressed and `status` shows no run, call `run`; their press was the ask, so call it without asking them again. When it ends you are told, on your next prompt or edit, what it found and the call to make, if `npx {{cortad}} stick` has been run in this repository (below); say that in one line, and offer to run it.
 
-`status` with `show` lists one section of the read in full: `rules`, `standards`, `journeys`, `endpoints` or `trials` (in a shell, `npx {{cortad}} status rules`).
+`status` with `show` lists one section of the read in full: `rules`, `standards`, `journeys`, `endpoints`, `trials`, `records` or `reviews` (in a shell, `npx {{cortad}} status rules`).
 
 ## Following a run
 

package/skill/references/results.md

@@ -12,8 +12,6 @@ Right after a connect, before the read is done:
 Cortad · tutor-app
 Free: 1 of 1 run left this month; 60 verify trials left. Pro $99 a month: runs and reruns included, 100,000 production replies read.
 App: Your app is starting on this machine.
-No run yet.
-Production: not connected.
 ```
 
 After the agent sent one real request to each endpoint that reaches the model, two on the chat, and before any run:
@@ -28,13 +26,18 @@ Endpoints your own requests proved (1):
     Tools that ran: search_lessons.
     Passages handed to the model: 3.
     Problem at apps/api/src/agent/system.ts:30: The reply carried "</student_profile>", markup from the prompt your app sent the model.
-    Last request: "and the second question?", answered "For question 2, start by writing what the angle is opposite to.".
+    Last message: "and the second question?".
 Endpoints the read found that no request has reached (1):
   POST /api/homework/explain  apps/api/src/routes/homework.ts:18
-A run on the proven endpoints: 36 trials, about 72 replies, about 6 minutes, about $0.38 on your OpenAI key for gpt-4o-mini.
-No run yet.
-Production: not connected.
-A run starts only when the person asks: from Run in the browser, or from the run verb.
+For the person: a run plays 36 conversations: about 72 replies in about 6 minutes. It costs about $0.38 on your OpenAI key for gpt-4o-mini. Every reply is checked against the 46 rules read from your code.
+A run starts when the person presses Run on the card in the browser or asks you for one; if they say they pressed it, call run rather than ask them again.
+```
+
+When the app keeps its data in a store off this machine that no copy can be made of, the decision is the person's, said once as the last line before the link:
+
+```
+For the person: DATABASE_URL points at the Postgres database shop off this machine, and no migrations were found to build a copy on this machine from, so the run would write into it as it is. Point DATABASE_URL at a database on this machine, then run the connect command again. Or one press on the card in the browser lets the run write into it and starts the run.
+For the person: https://cortad.com/lab shows this in the browser.
 ```
 
 Once a run is playing, the read and the run:
@@ -48,23 +51,21 @@ Rules in the code: 46, in 5 files. 3 of them:
   apps/api/src/agent/prompt.ts:41  "Never state a refund policy the product does not publish."
   apps/api/src/agent/system.ts:12  "Answer in the language the student writes in."
   apps/api/src/tools/search.ts:8  "Cite the lesson a fact comes from."
-Journeys (4): homework help, billing question, account recovery, first lesson.
-Simulated users (3): student in grade 9, parent paying for the plan, teacher checking progress.
-Endpoints (2): POST /api/chat, POST /api/homework/explain.
-Engineering standards: 38 decided, 35 met, 3 missed.
+Journeys (4): homework help; billing question; account recovery; first lesson.
+Simulated users (3): student in grade 9; parent paying for the plan; teacher checking progress.
+Engineering standards: your code misses 3 of the 38 Cortad checks.
   apps/api/src/agent/client.ts:9  The model call has a timeout: the OpenAI client is created with no timeout, so a slow reply holds the request open (decided by code)
   apps/api/src/agent/system.ts:30  User text stays out of the system prompt: the student's name is written into the system prompt (decided by a model)
   apps/api/src/tools/search.ts:51  Tool errors reach the model as errors: search returns an empty list when the index is down (decided by a model)
-Questions: 112; 40 asked in every conversation, 72 placed in the situations they fit.
-Trials: 58 written.
-  POST /api/homework/upload: 7 trials set aside, on the app's side: the route needs a signed file URL, and no test account can make one
+Conversations set aside:
+  POST /api/homework/upload: 7 conversations, on the app's side: the route needs a signed file URL, and no test account can make one
 Latest run 8f2a1c4e-5b6d-4e7f-9a0b-1c2d3e4f5a6b: running, 14 of 51 trials played.
 Production: not connected.
 For the person: https://cortad.com/lab shows this in the browser.
 next: run_status 8f2a1c4e-5b6d-4e7f-9a0b-1c2d3e4f5a6b
 ```
 
-Each section in full, with `show` (`rules`, `standards`, `journeys`, `endpoints` or `trials`). A list longer than one page ends with `page 1 of 3, call status with show rules and page 2`.
+Each section in full, with `show` (`rules`, `standards`, `journeys`, `endpoints`, `trials`, `records` or `reviews`). A list longer than one page ends with `page 1 of 3, call status with show rules and page 2`.
 
 ```
 Rules in the code: 16, in 5 files.
@@ -231,7 +232,7 @@ Stopped early. Each stop and fault names the side it is on and what comes next:
 ```
 Run 8f2a1c4e-5b6d-4e7f-9a0b-1c2d3e4f5a6b: finished, 11 of 51 trials played.
 1 finding.
-Stopped at 11 of 51 trials, on the app's side: your app stopped answering at turn 11. Bring your app back up, then run again.
+Stopped at 11 of 51 trials, on the app's side: your app stopped answering after 11 replies. Bring your app back up, then run again.
 Fault on the app's side: Your code names llama-3.1-8b-instant, which api.groq.com does not serve. Rename the model in your code, then run again.
 For the person: the report is at https://cortad.com/lab
 next: findings