cortad 0.3.1-rc.10 → 0.3.1-rc.12

package/lib/failed-text.mjs

@@ -0,0 +1,35 @@
+import { at, clip, plural } from "./words.mjs";
+
+// The replies that did not count and the doors that were not sent to, said before the score: one
+// sentence whose parts add up to the count, then the request behind each part that has one. A count
+// on its own ("17 of 33 replies failed") left resumeforge's agent asking what was attempted, whose it
+// was, and how to reproduce it.
+
+// A row the run held back names a door and why, or, when no door could take it, only the reason.
+export const heldBackLine = (h) => h.why === "not testable here"
+  ? `Held back: ${plural(h.trials, "trial")} cannot be played here: ${clip(h.surface, 200).replace(/\.$/, "")}.`
+  : `Held back: ${plural(h.trials, "trial")} on ${h.surface}${h.why ? `, ${clip(h.why, 200)}` : ""}.`;
+
+const HELD_SHOWN = 6;
+
+export function heldLines(held) {
+  const rows = (held ?? []).filter((h) => h.trials > 0);
+  const lines = rows.slice(0, HELD_SHOWN).map(heldBackLine);
+  if (rows.length > HELD_SHOWN) lines.push(`Held back: ${plural(rows.slice(HELD_SHOWN).reduce((n, h) => n + h.trials, 0), "more trial")} for ${plural(rows.length - HELD_SHOWN, "other reason")}.`);
+  return lines;
+}
+
+export function failedLines(f) {
+  if (!f) return [];
+  const lines = f.said ? [f.said] : [];
+  for (const row of f.rows ?? []) {
+    const sent = row.curl ?? row.request;
+    if (!sent && !row.verify) continue;
+    const [path, line] = (row.at ?? "").split(/:(?=\d+$)/);
+    const where = row.at ? `at ${at(path, Number(line))}` : `from ${row.door}`;
+    if (sent) lines.push(`  Request for the ${row.count} ${where}: ${clip(sent, 900)}`);
+    if (sent && row.response) lines.push(`    Answered: ${clip(row.response.replace(/\s+/g, " "), 300)}`);
+    if (row.verify) lines.push(sent ? `    verify ${row.verify} replays them.` : `  verify ${row.verify} replays the ${row.count} ${where}.`);
+  }
+  return [...lines, ...heldLines((f.held ?? []).map((h) => ({ surface: h.door, trials: h.trials, why: h.why })))];
+}

package/lib/health.mjs

@@ -0,0 +1,53 @@
+// Whether the app a run is using is alive, read the way a person would: is its process still there,
+// does anything still hold its port, and only then does it answer. An app slow to answer because it
+// is answering our own requests is working, not dead: resumeforge held sixteen of them on a database
+// pool of five, missed two probes of 2.5 seconds, and was restarted in the middle of the run.
+import { connect } from "node:net";
+
+const FLOOR_MS = 10_000;
+const CAP_MS = 120_000;
+const url = (host, port) => `http://${host === "::1" ? "[::1]" : host}:${port}/`;
+
+// Opens the socket and sends nothing. Only a refusal means nobody holds the port: a listener too
+// busy to accept still holds it.
+export const portHeld = (host, port, ms = 3000) => new Promise((done) => {
+  const socket = connect({ host, port });
+  const end = (held) => { socket.destroy(); done(held); };
+  socket.once("connect", () => end(true));
+  socket.once("error", (e) => end(e.code !== "ECONNREFUSED"));
+  socket.setTimeout(ms, () => end(true));
+});
+
+// `gone`: the process this command started has exited. `inFlight`: the run's requests the app has
+// not answered yet. The probe waits three times the app's last reply to it, never under ten seconds
+// or over two minutes.
+export function makeHealth({ host, gone, inFlight }) {
+  let took = 0;
+  const timeout = () => Math.min(CAP_MS, Math.max(FLOOR_MS, took * 3));
+  return {
+    timeout,
+    // "up", "busy" (slow while the run's requests are open: never restarted), or why it is down:
+    // "exited", "released" (nothing holds its port) or "quiet" (no answer with nothing of ours open).
+    async check(port) {
+      if (gone()) return "exited";
+      if (!(await portHeld(host(), port))) return "released";
+      const started = Date.now();
+      try {
+        const res = await fetch(url(host(), port), { method: "GET", signal: AbortSignal.timeout(timeout()), redirect: "manual" });
+        await res.body?.cancel();
+        took = Date.now() - started;
+        return "up";
+      } catch {
+        return inFlight() > 0 ? "busy" : "quiet";
+      }
+    },
+  };
+}
+
+// The runner's own line for a restart, in the person's words.
+export function downLine(state, { port, downMs, crashed = false }) {
+  if (crashed) return "your app crashed, starting it again";
+  if (state === "exited") return "your app exited, starting it again";
+  if (state === "released") return `nothing is listening on port ${port} any more, starting your app again`;
+  return `your app has not answered for ${Math.round(downMs / 1000)} seconds while no test conversation was waiting on it, starting it again`;
+}

package/lib/pyhook/sitecustomize.py

@@ -964,7 +964,10 @@ def _install():
     # ran by it, where the read could only name the door. Its frames on this stack outside installed
     # packages, then, when the call runs in a task another task awaits (LangChain runs each step of a
     # chain as its own task), the awaiting task's. Relative to the folder the app was started in.
+    # Five lines: a provider class's stream, post and retry can be three lines of one file, and the
+    # line that says which path ran is past them.
     root = os.getcwd().replace(os.sep, "/").rstrip("/") + "/"
+    callers_max = 5
     installed = re.compile(r"/(?:site-packages|dist-packages|\.venv|venv|__pypackages__)/|/lib/python\d")
 
     def ours(frame, out):
@@ -973,7 +976,7 @@ def _install():
             at = "%s:%d" % (f[len(root):], frame.f_lineno)
             if at not in out:
                 out.append(at)
-        return len(out) >= 3
+        return len(out) >= callers_max
 
     # The task that waits on this one: its wake-up is among this one's callbacks, directly, or behind
     # the future an asyncio.gather callback closes over.

package/lib/replay.mjs

@@ -124,7 +124,8 @@ const calledOf = (v) => {
 const passagesOf = (v) => (texts(v).length ? { passages: texts(v).slice(0, 6) } : {});
 // Which of the app's own lines made the call, nearest first, as "path:line".
 const AT = /^[^\n\r\t]{1,300}:\d{1,7}$/;
-const callerOf = (v) => { const caller = Array.isArray(v) ? v.filter((c) => typeof c === "string" && AT.test(c)).slice(0, 3) : []; return caller.length ? { caller } : {}; };
+const CALLERS_MAX = 5;
+const callerOf = (v) => { const caller = Array.isArray(v) ? v.filter((c) => typeof c === "string" && AT.test(c)).slice(0, CALLERS_MAX) : []; return caller.length ? { caller } : {}; };
 const meter = (() => {
   const rows = [];
   const deps = [];

package/lib/text.mjs

@@ -1,3 +1,4 @@
+import { failedLines, heldLines } from "./failed-text.mjs";
 import { readLines } from "./read-text.mjs";
 import { at, clip, has, num, PAGE_CHARS, pageOf, plural, SIDE, upper } from "./words.mjs";
 
@@ -59,15 +60,13 @@ function measuredLines(d) {
 
 function scoreText(d, of) {
   const floor = has(d.decided) && d.decided < 22;
-  // The replies that failed stand beside the number: a 100 over the replies that answered, with 62 of
-  // 89 error replies unsaid, read as a clean bill.
-  const crashed = d.replies && d.replies.crashed > 0 ? `; ${num(d.replies.crashed)} of ${plural(d.replies.total, "reply", "replies")} were failures and are not in it` : "";
+  // The replies that did not count stand beside the number, in the same counts the lines above it
+  // give: a 100 over the replies that answered, with 62 of 89 error replies unsaid, read as a clean bill.
+  const f = d.failedReplies;
+  const crashed = f ? (f.notCounted > 0 ? `; the ${num(f.notCounted)} of ${plural(f.replies, "reply", "replies")} that did not count are not in it` : "")
+    : d.replies && d.replies.crashed > 0 ? `; ${num(d.replies.crashed)} of ${plural(d.replies.total, "reply", "replies")} were failures and are not in it` : "";
   return `${floor ? "provisional score" : "score"} ${num(d.score)} of 100${of ? ` on those ${num(d.questionsAsked)}` : ""}${interval(d.ci)}${floor ? `, from ${plural(d.decided, "decided reading")}: under the 22-reading floor, so not a verdict yet` : ""}${crashed}`;
 }
-// A row the run held back names a door and why, or, when no door could take it, only the reason.
-const heldBackLine = (h) => h.why === "not testable here"
-  ? `Held back: ${plural(h.trials, "trial")} cannot be played here: ${clip(h.surface, 200).replace(/\.$/, "")}.`
-  : `Held back: ${plural(h.trials, "trial")} on ${h.surface}${h.why ? `, ${clip(h.why, 200)}` : ""}.`;
 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 score covers the turns 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 in its own paired line.
@@ -86,12 +85,14 @@ function runLines(d, prefix = "") {
   const played = d.of ? `${num(d.played ?? 0)} of ${plural(d.of, "trial")} played` : "no trial played yet";
   const lines = [`${upper(`${prefix}${d.kind === "verify" ? "verify" : "run"}`)} ${d.jobId}: ${d.status === "succeeded" || !d.status ? (done ? "finished" : "running") : d.status}, ${played}.`];
   if (d.tested) lines.push(testedLine(d.tested));
+  // Each endpoint's first conversation, played alone before the others: whether it held and why not.
+  lines.push(...(d.first ?? []));
   // Between two counts, what the run is doing now: four minutes of "0 of 15" read as nothing happening.
   if (!done && d.now?.doing) lines.push(d.now.doing);
   lines.push(...waitLines(d));
   // A verify is a move, not a score: "100 of 100" on a replay whose run before decided nothing read
   // as a clean bill to bloom's agent, beside "zero verified fixes".
-  if (done && d.kind !== "verify") lines.push(...measuredLines(d));
+  if (done && d.kind !== "verify") lines.push(...failedLines(d.failedReplies), ...measuredLines(d));
   if (done && d.blocked) lines.push(d.blocked);
   if (done && d.notCounted) lines.push(d.notCounted);
   if (done && d.halted) lines.push(haltLine(d.halted));
@@ -99,10 +100,9 @@ function runLines(d, prefix = "") {
   if (done && has(d.findings)) lines.push(`${plural(d.findings, "finding")}.`);
   const trials = trialsLine(d);
   if (trials) lines.push(trials);
-  // Every row, or six and the rest in one line, so the rows always sum to the held-back count.
-  const heldRows = (d.heldBack ?? []).filter((h) => h.trials > 0);
-  for (const h of heldRows.slice(0, 6)) lines.push(heldBackLine(h));
-  if (heldRows.length > 6) lines.push(`Held back: ${plural(heldRows.slice(6).reduce((n, h) => n + h.trials, 0), "more trial")} for ${plural(heldRows.length - 6, "other reason")}.`);
+  // Every row, or six and the rest in one line, so the rows always sum to the held-back count. A
+  // finished run says them with the replies that did not count, above the score.
+  if (!(done && d.failedReplies)) lines.push(...heldLines(d.heldBack));
   const reads = readingsLine(d);
   if (reads) lines.push(reads);
   if (d.stopped) lines.push(stoppedLine(d));
@@ -140,7 +140,8 @@ function readingsLine(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;
-  const turn = s.after > 0 ? ` at turn ${s.after}` : "";
+  // 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}` : "";
   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}`;
@@ -222,8 +223,10 @@ export function testedLine(t) {
   return `App started ${started}${t.reloads ? " and reloads itself on save" : ""}; your last change was at ${clock(t.change.at)}.`;
 }
 
-export const waitingText = (p, now, limitMs) =>
-  `Your app is still starting for the ${p.kind === "verify" ? "verify" : "run"}: ${num((now - Date.parse(p.startedAt)) / 1000)} of up to ${num(limitMs / 1000)} seconds.\nnext: run_status pending`;
+// `said`: the status's own word on the app, which knows when it already answers and only its AI
+// endpoint is still being found; bloom's agent read "still starting" beside "your app is answering".
+export const waitingText = (p, now, limitMs, said) =>
+  `${said ? String(said).replace(/\.$/, "") : `Your app is still starting for the ${p.kind === "verify" ? "verify" : "run"}`}: ${num((now - Date.parse(p.startedAt)) / 1000)} of up to ${num(limitMs / 1000)} seconds.\nnext: run_status pending`;
 
 // A spent plan: what the last run found, what was fixed since, what the next run would play.
 export function refusedText(d) {
@@ -277,7 +280,7 @@ function findingsHead(d) {
   if (!d.runId) return ["No run has finished on this repository yet."];
   const lines = [`Run ${d.runId}: ${plural(d.findings?.length ?? 0, "finding")}.`];
   if (d.tested) lines.push(testedLine(d.tested));
-  lines.push(...measuredLines(d));
+  lines.push(...failedLines(d.failedReplies), ...measuredLines(d));
   if (d.blocked) lines.push(d.blocked);
   if (d.halted) lines.push(haltLine(d.halted));
   lines.push(...waitLines(d));
@@ -338,7 +341,9 @@ function findingBlock(f, placed) {
     return lines.join("\n");
   }
   const lines = [`${f.id}  ${f.asks}`];
-  if (!placed && f.file) lines.push(`  At ${at(f.file, f.line)}`);
+  // What the line is when it is not the check's own: the tool that ran, or only the model call.
+  if (f.addressed) lines.push(`  At ${at(f.file, f.line)}: ${f.addressed}`);
+  else if (!placed && f.file) lines.push(`  At ${at(f.file, f.line)}`);
   if (f.criteria) lines.push(`  Criteria: ${clip(f.criteria, 600)}`);
   if (f.door) lines.push(`  Endpoint: ${f.door}`);
   else if (f.doors?.length) lines.push(`  Endpoints: ${f.doors.join(", ")}`);

package/lib/trace.cjs

@@ -137,13 +137,15 @@ if (FILE) {
     // The file that registered a route: the first frame outside this hook and outside node_modules.
     const callerFile = () => { const f = stackFrames()[0]; return f && !f.file.startsWith("..") ? f.file : ""; };
     // Which of the app's own lines made a model call, nearest first: the run names the code path that
-    // ran by it, where the read could only name the door.
+    // ran by it, where the read could only name the door. Five lines: a provider class's stream, post
+    // and retry can be three lines of one file, and the line that says which path ran is past them.
+    const CALLERS_MAX = 5;
     const callers = () => {
       const out = [];
       for (const f of stackFrames()) {
         const at = `${f.file}:${f.line}`;
         if (!f.file.startsWith("..") && !out.includes(at)) out.push(at);
-        if (out.length === 3) break;
+        if (out.length === CALLERS_MAX) break;
       }
       return out.length ? out : undefined;
     };

package/lib/verbs.mjs

@@ -109,7 +109,7 @@ export function makeVerbs({ api, token, fetchImpl = fetch, startApp, pending, ro
     if (p.jobId) return { id: p.jobId };
     if (p.error) return { text: `${p.error}\nnext: status`, isError: true };
     if (stale()) return { text: "The process starting your app for the run ended without a result.\nNothing ran.\nnext: status", isError: true };
-    return { text: waitingText(p, now(), READY_MS) };
+    return { text: waitingText(p, now(), READY_MS, latest.data.app?.state === "starting" && latest.data.app.port ? latest.data.app.said : null) };
   };
 
   const runStatus = async ({ jobId } = {}) => {

package/local.mjs

@@ -34,6 +34,7 @@ import { listingUrl } from "./lib/listing.mjs";
 import { installPlan, missingDependency, startPlan, workspaces } from "./lib/start.mjs";
 import { openSwitches } from "./lib/switches.mjs";
 import { keepData } from "./lib/data.mjs";
+import { downLine, makeHealth } from "./lib/health.mjs";
 import { markRun, writesDirOf } from "./lib/writes.mjs";
 
 const argv = process.argv.slice(2);
@@ -275,6 +276,9 @@ let appGone = false;
 let lastSaid = "";
 let lastOutputAt = Date.now();
 let forgetTold = null;
+// The run's requests your app has not answered yet: a slow health probe while any are open is our
+// load on it, not a hang.
+let answering = 0;
 const mask = (text) => { let s = String(text ?? ""); for (const v of secrets) s = s.split(v).join("[masked]"); return s; };
 
 // ---- the wire
@@ -405,12 +409,13 @@ async function verb(job) {
         const said = Object.fromEntries([...res.headers].filter(([k]) => !/^set-cookie2?$/i.test(k)).map(([k, v]) => [k, mask(v)]));
         return { status: res.status, headers: said, body: mask(buf.subarray(0, LIMIT).toString("utf8")), truncated: buf.length > LIMIT };
       };
-      try { return await ask(); }
+      const counted = async () => { answering += 1; try { return await ask(); } finally { answering -= 1; } };
+      try { return await counted(); }
       catch (e) {
         const code = String(e.cause?.code ?? e.code ?? "");
         if (!/ECONNREFUSED|ECONNRESET|EPIPE|UND_ERR_SOCKET/.test(code)) return { error: `nothing answered at port ${port}: ${code || e.message}` };
         for (let i = 0; i < 45 && !(await answers(port)); i++) await new Promise((r) => setTimeout(r, 1000));
-        try { return { ...(await ask()), heldForRestart: true }; }
+        try { return { ...(await counted()), heldForRestart: true }; }
         catch (again) { return { error: `nothing answered at port ${port}: ${String(again.cause?.code ?? again.message)}` }; }
       }
     }
@@ -854,6 +859,7 @@ async function restartApp() {
 async function restartNow() {
   if (!launched || !child) return { error: "You started this app yourself, so restart it in your own terminal. Most dev servers reload on save." };
   const port = app.port;
+  say("starting your app again so it runs the code you saved, since it does not reload by itself");
   await stopApp(child.pid);
   // Until the port is free, not merely silent: a listener still closing does not answer and still
   // holds the bind, and the restarted app was moved to the next port while the run kept knocking on
@@ -1073,26 +1079,30 @@ async function appLife() {
   let toldDown = false;
   let appTold = true;
   forgetTold = () => { appTold = false; };
+  const health = makeHealth({ host: () => appHost, gone: () => Boolean(launched && appGone), inFlight: () => answering });
   for (let up = true; !closing;) {
     await new Promise((r) => setTimeout(r, 2000));
     if (closing || restarting) continue;
-    const now = await answers(app.port);
-    if (now) {
+    const state = await health.check(app.port);
+    if (state === "up") {
       downSince = 0; toldDown = false;
       // Said until it is heard. Said once, it was lost when their app came back while the network
       // was down, and the screen went on showing an app that had stopped while it answered turns.
       if (!up || !appTold) { up = true; appTold = Boolean((await announce().catch(() => null))?.ok); }
       continue;
     }
+    // Running, holding its port, and slow because it is answering the run's own requests: working,
+    // not dead. Nothing is said and nothing restarts, and a silence after it is timed from here.
+    if (state === "busy") { if (!up) downSince = Date.now(); continue; }
     if (up) { up = false; downSince = Date.now(); }
     appTold = false;
     const downFor = Date.now() - downSince;
-    // Not answering. A dev server restarting on a save is busy and says so in its output: it is
-    // left alone, however long its own startup takes.
-    // A watcher that has said its app crashed is not busy, it is waiting, and says so.
+    // Not answering. A dev server restarting on a save says so in its output: it is left alone,
+    // however long its own startup takes.
+    // A watcher that has said its app crashed is not reloading, it is waiting, and says so.
     const crashed = /app crashed - waiting|Failed running|waiting for (?:file )?changes before restart/i.test(lastSaid.slice(-600));
-    const busy = launched && !appGone && !crashed && Date.now() - lastOutputAt < 15_000;
-    if (busy || downFor < (crashed ? 4_000 : 10_000)) continue;
+    const reloading = launched && !appGone && !crashed && Date.now() - lastOutputAt < 15_000;
+    if (reloading || downFor < (crashed ? 4_000 : 10_000)) continue;
     // Down for real. The screen is told, so it never shows an app that is not there.
     // `exited`: the process this command started is gone or its watcher said it crashed, not a process
     // running and not answering. The run tells the two apart: one is their crash, the other may be our
@@ -1108,7 +1118,7 @@ async function appLife() {
     restarting = true;
     try {
       if (child?.pid) await stopApp(child.pid);
-      say("your app stopped answering, starting it again");
+      say(downLine(state, { port: app.port, downMs: downFor, crashed }));
       let back = launched ? await launch(180_000) : await startApp();
       while (!back.port && !closing) {
         await call("POST", `/local/${box}/stopped`, { said: mask(back.tail || back.said || lastSaid).slice(-2000) }).catch(() => {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortad",
-  "version": "0.3.1-rc.10",
+  "version": "0.3.1-rc.12",
   "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"
@@ -10,7 +10,9 @@
     "README.md",
     "lib/cli.mjs",
     "lib/data.mjs",
+    "lib/failed-text.mjs",
     "lib/fresh.mjs",
+    "lib/health.mjs",
     "lib/home.mjs",
     "lib/identities.mjs",
     "lib/keys.mjs",

package/skill/SKILL.md

@@ -49,7 +49,7 @@ Take the person through them worst first, each with its file and line. A long li
 
 ## Fixing one finding
 
-Each finding ends with what a verify of it can show. When the trials it replays read the question too few times for a rate, the verify plays up to 12 more trials in that situation itself, counted as verify trials, and the finding says how many before one is spent.
+Each finding ends with what a verify of it can show. When the trials it replays read the question too few times for a rate, the verify plays up to 12 more trials itself, in the finding's situations that were read least, counted as verify trials, and the finding says how many before one is spent. A finding listed in several situations is verified in all of them.
 
 1. One change, in the file and near the line the finding names.
 2. `verify <findingId>`. It answers within a second, and `run_status` follows it. When the app's code changed since the app started and nothing reloaded it, Cortad starts the app again first and the answer says so, so the saved edit is what plays; `run_status` names when the app started against the last change. When it also plays new trials in the finding's situation, the answer says how many.

package/skill/references/results.md

@@ -130,6 +130,21 @@ For the person: the report is at https://cortad.com/lab
 next: findings
 ```
 
+Replies that did not count come before the score, each part saying whose it is, with the request to paste where there is one:
+
+```
+Run 8f2a1c4e-5b6d-4e7f-9a0b-1c2d3e4f5a6b: finished, 31 of 31 trials played.
+17 of 33 replies did not count: 9 answered HTTP 502 at backend/app/api/resume_writing.py:91 (yours; request below), 6 refused the shape we sent to POST /api/drill/{id}/answer (HTTP 422) (ours; request below), 2 got no answer from /api/chat before we stopped waiting at 90 seconds (ours).
+  Request for the 9 at backend/app/api/resume_writing.py:91: curl -X POST 'http://localhost:8004/api/resume/writing' -H 'authorization: <redacted>' -H 'content-type: application/json' --data-raw '{"message":"rewrite my summary"}'
+    Answered: Bad Gateway
+    verify finding:1 replays them.
+  Request for the 6 from /api/drill/{id}/answer: curl -X POST 'http://localhost:8004/api/drill/7/answer' -H 'content-type: application/json' --data-raw '{"message":"hi"}'
+    Answered: {"detail":[{"loc":["body","answer"],"msg":"field required"}]}
+20 of 40 checks measured; score 88 of 100 on those 20, interval 70 to 96; the 17 of 33 replies that did not count are not in it.
+```
+
+A part marked yours is the app failing: run the request, fix what it shows, then verify the finding named. A part marked ours is Cortad's to fix, and nothing in the app changes for it. A masked value (`<redacted>`) is the app's own sign-in or key; put it back before running the request.
+
 Your app stopped during the run and was started again: that is a finding of its own, `crash:1`, with the error your app printed and the turn it happened at. Fix the error it quotes. It has no trials to replay, so `verify` refuses it; the next run that finishes without it is the proof. A `Data:` line says whether the run wrote to a copy of your app's database or into the real one.
 
 A verify that holds: both intervals are above zero and the held-out trials moved with the visible ones.