@cortad/connector 0.6.1 → 0.6.3

package/lib/behavior-text.mjs

@@ -0,0 +1,239 @@
+import { at, clip, num, plural, upper } from "./words.mjs";
+
+// The behavior review as a coding agent reads it: who the users were, what they wanted, who achieved
+// it, what the app did well and where it gave way, and only then where in the code each problem comes
+// from. Every count has its denominator and every rate its range. Only a simulated conversation is
+// ever quoted: a real user's words could instruct the agent reading this, so a production
+// conversation is said by its id and the address where the owner reads it, whatever the server sends.
+
+const PROBLEMS_SHOWN = 3;
+// The largest personas in full, and every flagged one; the rest a line each.
+const PERSONAS_SHOWN = 6;
+const PLACES_SHOWN = 8;
+const IDS_SHOWN = 5;
+const QUOTE_CHARS = 240;
+
+const short = (id) => String(id).slice(0, 8);
+const pct = (s) => (s.of ? Math.round((100 * s.n) / s.of) : 0);
+export const rateSaid = (s) => `${num(s.n)} of ${plural(s.of, "conversation")}, ${pct(s)}% (${s.low}% to ${s.high}%)`;
+const day = (iso) => new Date(iso).toLocaleDateString("en-GB", { day: "numeric", month: "long", year: "numeric", timeZone: "UTC" });
+const time = (iso) => new Date(iso).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit", timeZone: "UTC" });
+const ended = (t) => (/[.?!]$/.test(t) ? t : `${t}.`);
+const quoted = (s) => `"${clip(String(s).replace(/"/g, "'"), QUOTE_CHARS)}"`;
+
+export function pointSaid(p) {
+  if (p.kind === "production") return p.from === p.to ? `production on ${day(p.from)}` : `production from ${day(p.from)} to ${day(p.to)}`;
+  const commit = p.commit ? ` on commit ${p.commit.slice(0, 7)}${p.message ? ` (${quoted(p.message)})` : ""}` : "";
+  return `the simulation of ${day(p.at)} at ${time(p.at)} UTC${commit}`;
+}
+
+const who = (p) => (p.kind === "production" ? "real users" : "simulated users");
+
+function behaves(m) {
+  if (!m) return null;
+  const parts = [`${plural(m.messages, "message")} a conversation`];
+  if (m.words) parts.push(`a first message of about ${plural(m.words, "word")}`);
+  const share = (v, what) => (v > 0 ? `${Math.round(v * 100)}% of them ${what}` : null);
+  const more = [share(m.pushesBack, "push back"), share(m.asksForPerson, "ask for a person"), share(m.leftUnanswered, "leave a question unanswered"), share(m.comesBack, "come back on another day")].filter(Boolean);
+  return `They send ${parts.join(", with ")}${more.length ? `; ${more.join(", ")}` : ""}.`;
+}
+
+// personas() writes each insight with its own counts and ranges; the conversations are added.
+const insightLine = (i) => {
+  const ids = (i.evidence?.conversations ?? []).slice(0, IDS_SHOWN).map(short).join(", ");
+  return `   - ${i.text}${ids ? ` Shown in ${ids}.` : ""}`;
+};
+const wellLine = (w) => `   - ${w.text.replace(/\.$/, "")}: in ${rateSaid(w.share)}${w.apart && w.others ? `, against ${pct(w.others)}% (${w.others.low}% to ${w.others.high}%) for the other users` : ""}.`;
+const insightsOf = (p, kind) => (p.insights ?? []).filter((i) => i.kind === kind);
+
+function problemLines(p, real, quote) {
+  const lines = [`   - ${p.said ?? `${p.text.replace(/\.$/, "")}: in ${rateSaid(p.share)}.`}${p.findingId ? ` (${p.findingId})` : ""}`];
+  const ids = p.conversations.slice(0, IDS_SHOWN).map(short);
+  if (ids.length) lines.push(`     Shown in ${ids.join(", ")}${p.conversations.length > ids.length ? ` and ${num(p.conversations.length - ids.length)} more` : ""}.`);
+  if (quote && p.quote && !real) {
+    lines.push(`     In ${short(p.quote.conversation)}:`);
+    if (p.quote.asked) lines.push(`       The user: ${quoted(p.quote.asked)}`);
+    lines.push(`       Reply ${p.quote.reply}: ${quoted(p.quote.quote || p.quote.said)}`);
+  }
+  return lines;
+}
+
+function personaLines(p, i, point, whole) {
+  const real = point.kind === "production";
+  const head = `${i + 1}. ${p.name}${p.flagged ? " [flagged: these users misuse the app]" : ""}: ${plural(p.users, real ? "user" : "simulated user")}, ${plural(p.conversations, "conversation")}.`;
+  const lines = [head];
+  if (p.flagged && p.why) lines.push(`   Why flagged: ${p.why}`);
+  if (p.facts?.length) lines.push(`   Who they are: ${p.facts.map((f) => `${f.key} ${f.values.map((v) => `${v.value} ${Math.round(v.share * 100)}%`).join(", ")}`).join("; ")}.`);
+  const b = behaves(p.measures);
+  if (b) lines.push(`   ${b}`);
+  lines.push(p.servedSaid ? `   ${p.servedSaid}` : p.served ? `   They achieved their goal in ${rateSaid(p.served)}.` : "   Whether they achieved their goal is not known for these conversations.");
+  lines.push(...insightsOf(p, "served").map(insightLine));
+  if (insightsOf(p, "trait").length) lines.push("   How they behave, read from their conversations:", ...insightsOf(p, "trait").map(insightLine));
+  const well = (p.well ?? []).map(wellLine);
+  if (well.length) lines.push("   What the app did well with them:", ...well);
+  const shown = whole ? p.problems : p.problems.slice(0, PROBLEMS_SHOWN);
+  const read = insightsOf(p, "problem");
+  if (shown.length || read.length) {
+    lines.push("   Where it gave way:", ...read.map(insightLine));
+    shown.forEach((x, k) => lines.push(...problemLines(x, real, whole || k === 0)));
+  } else lines.push("   No problem was seen in more than one of their conversations.");
+  const more = p.problems.length - shown.length;
+  if (more > 0) lines.push(`   ${plural(more, "more problem")} in more than one conversation: behavior with persona: "${p.name}" lists them.`);
+  if (p.seenOnce) lines.push(`   ${plural(p.seenOnce, "problem was", "problems were")} seen in one conversation alone, which is not yet a pattern.`);
+  if (whole && p.list?.length) {
+    lines.push(`   Their conversations${p.list.length < p.conversations ? `, the first ${num(p.list.length)} of ${num(p.conversations)}` : ""}:`);
+    for (const c of p.list) {
+      const got = c.served === true ? "achieved their goal" : c.served === false ? "did not achieve their goal" : "not known whether they achieved it";
+      const what = real ? got : `${quoted(c.asked)}; ${got}`;
+      lines.push(`   - ${short(c.id)}: ${what}${c.problems.length ? `; went wrong: ${c.problems.map((t) => t.replace(/\.$/, "")).join("; ")}` : ""}.${real && c.open ? ` Open: ${c.open}` : ""}`);
+    }
+  }
+  return lines;
+}
+
+function codeLines(code) {
+  if (!code.length) return [];
+  const lines = ["Where each problem comes from in the code:"];
+  for (const place of code.slice(0, PLACES_SHOWN)) {
+    lines.push(`- ${at(place.path, place.line)}`);
+    for (const p of place.problems) lines.push(`  ${p.text.replace(/\.$/, "")}: ${plural(p.conversations, "conversation")} of ${p.personas.length === 1 ? `"${p.personas[0]}"` : plural(p.personas.length, "persona")}.${p.findingId ? ` Verify with findingId "${p.findingId}" replays them after a fix.` : ""}`);
+  }
+  if (code.length > PLACES_SHOWN) lines.push(`${plural(code.length - PLACES_SHOWN, "more place")} in the code, each behind fewer conversations.`);
+  return lines;
+}
+
+export function behaviorText({ review: r }) {
+  const real = r.point.kind === "production";
+  const one = r.personas.length === 1 && r.personas[0].list;
+  const lines = [`How your app behaved with its users: ${pointSaid(r.point)}.`];
+  const served = r.served ? ` Of the ${plural(r.served.of, "conversation")} where it could be told, ${num(r.served.n)} achieved their goal: ${pct(r.served)}% (${r.served.low}% to ${r.served.high}%).` : "";
+  lines.push(one
+    ? `One persona in full, of ${plural(r.users, real ? "real user" : "simulated user")} and ${plural(r.conversations, "conversation")} in all.`
+    : `${usersSaid(r.users, r.personas.length, real)}, in ${plural(r.conversations, "conversation")}.${served}`);
+  if (real && r.point.open) lines.push(`Real users' words are not shown here. The owner reads any conversation below at ${r.point.open}<id>.`);
+  lines.push("");
+  const full = r.personas.filter((p, i) => i < PERSONAS_SHOWN || p.flagged);
+  r.personas.forEach((p, i) => { if (full.includes(p)) lines.push(...personaLines(p, i, r.point, Boolean(one)), ""); });
+  const rest = r.personas.filter((p) => !full.includes(p));
+  if (rest.length) {
+    lines.push(`${plural(rest.length, "more persona")}, smaller; behavior with persona opens any of them:`);
+    for (const p of rest) lines.push(`- ${p.name}: ${plural(p.users, real ? "user" : "simulated user")}, ${plural(p.conversations, "conversation")}${p.served ? `, achieved their goal in ${rateSaid(p.served)}` : ""}${p.problems[0] ? `; most often: ${p.problems[0].text.replace(/\.$/, "")}, in ${num(p.problems[0].share.n)} of ${num(p.problems[0].share.of)}` : ""}.`);
+    lines.push("");
+  }
+  if (r.habits && !one) {
+    lines.push(`The app's habits across personas, read from ${plural(r.habits.conversations, "conversation")}:`);
+    if (r.habits.doesWell) lines.push(`- Does well: ${r.habits.doesWell}`);
+    if (r.habits.givesWay) lines.push(`- Gives way: ${r.habits.givesWay}`);
+    if (r.habits.pattern) lines.push(`- The habit behind it: ${r.habits.pattern}`);
+    lines.push("");
+  }
+  lines.push(...codeLines(r.code));
+  const top = r.personas[0]?.name;
+  lines.push(one
+    ? `next: tell the person how their AI behaved with "${top}", in plain words, then what you would change and why it follows${real ? "" : `; behavior with against: "production" says how these simulated users compare with real ones`}`
+    : `next: tell the person how their AI behaved with their users, persona by persona, then what you would change and why it follows${top ? `; behavior with persona: "${top}" opens the largest in full` : ""}`);
+  return lines.join("\n");
+}
+
+// Users of personas; where each persona holds one user, the grouping says nothing and is not claimed.
+const usersSaid = (users, personas, real) => {
+  const who = plural(users, real ? "real user" : "simulated user");
+  return personas >= users ? `${upper(who)}, each with a goal of their own` : `${upper(who)} of ${plural(personas, "persona")}`;
+};
+
+// A simulation against production compares two kinds of users, not a before and an after: the words
+// are about how hard the simulation is on the app next to its real users.
+function simulatedAgainstReal(served) {
+  const [sim, real] = [served.now, served.before];
+  const said = `Simulated users achieved their goal in ${pct(sim)}% of conversations (${sim.low}% to ${sim.high}%), real users in ${pct(real)}% (${real.low}% to ${real.high}%)`;
+  return served.move.moved === "up" ? `${said}: the simulation is easier on your app than your real users are.`
+    : served.move.moved === "down" ? `${said}: the simulation is harder on your app than your real users are.`
+    : `${said}: no clear difference.`;
+}
+
+const changeWord = { better: "Better", worse: "Worse", new: "New", gone: "Gone", same: "Same" };
+// Against production the two sides are two kinds of users at once, not a before and an after.
+const unlikeWord = { better: "Less often with simulated users", worse: "More often with simulated users", new: "Only simulated users met this", gone: "Only real users met this", same: "Same" };
+const moveSaid = (m) => `${m.points > 0 ? "up" : m.points < 0 ? "down" : "no change,"} ${Math.abs(m.points)} points (${m.low} to ${m.high})`;
+
+export function againstText({ against: d }) {
+  const vsReal = d.before.kind !== d.now.kind;
+  const lines = ["What changed for each persona.", `Now: ${pointSaid(d.now)}${vsReal ? `, its ${who(d.now)}` : ""}.`, `Before: ${pointSaid(d.before)}${vsReal ? `, its ${who(d.before)}` : ""}.`];
+  if (vsReal) lines.push("Where the two behave differently, the simulation is not playing your users as they are.");
+  lines.push("A rate counts as moved only where its range on the difference leaves out zero.");
+  lines.push("");
+  const words = vsReal ? unlikeWord : changeWord;
+  for (const p of d.personas.filter((x) => !x.only)) {
+    lines.push(`- ${p.name}: ${plural(p.users.now, "user")} now, ${num(p.users.before)} before.`);
+    if (vsReal && p.measures.now && p.measures.before) {
+      const m = (x) => `${plural(x.messages, "message")} a conversation${x.words ? `, first message about ${plural(x.words, "word")}` : ""}`;
+      lines.push(`  ${upper(who(d.now))}: ${m(p.measures.now)}. ${upper(who(d.before))}: ${m(p.measures.before)}.`);
+    }
+    if (vsReal && p.served.now && p.served.before) lines.push(`  ${simulatedAgainstReal(p.served)}`);
+    else if (p.served.now && p.served.before) lines.push(`  Achieved their goal: ${pct(p.served.now)}% now (${p.served.now.low}% to ${p.served.now.high}%), ${pct(p.served.before)}% before (${p.served.before.low}% to ${p.served.before.high}%): ${p.served.change === "same" ? "no clear change" : p.served.change}, ${moveSaid(p.served.move)}.`);
+    for (const x of p.problems) lines.push(`  ${words[x.change]}: ${ended(x.text)} ${num(x.now.n)} of ${num(x.now.of)} now, ${num(x.before.n)} of ${num(x.before.of)} before: ${moveSaid(x.move)}.${x.findingId ? ` (${x.findingId})` : ""}`);
+    if (p.unchanged) lines.push(`  ${plural(p.unchanged, "other problem")} did not clearly move.`);
+    if (p.oneSided) lines.push(`  ${plural(p.oneSided, "problem was", "problems were")} checked on one side only, so not compared.`);
+  }
+  for (const side of ["now", "before"]) {
+    const only = d.personas.filter((x) => x.only === side);
+    const label = vsReal ? (side === "now" ? "Only in the simulation" : "Only in production, never played by this simulation") : `Only ${side}`;
+    if (only.length) lines.push(`- ${label}: ${only.map((x) => `${x.name} (${plural(side === "now" ? x.users.now : x.users.before, "user")})`).join("; ")}.`);
+  }
+  lines.push(vsReal
+    ? `next: tell the person where the simulation plays their users unlike real ones, in plain words; behavior with persona: "<name>" opens one`
+    : `next: tell the person which personas got better or worse and why, in plain words; behavior with persona: "<name>" opens one`);
+  return lines.join("\n");
+}
+
+function entryLine(e) {
+  const served = e.served ? `, achieved their goal in ${rateSaid(e.served)}` : "";
+  const head = `- ${upper(pointSaid(e.point))}${e.point.kind === "simulation" ? ` (id ${e.point.id})` : ""}: ${usersSaid(e.users, e.personas, e.point.kind === "production")}${served}.`;
+  if (!e.change) return head;
+  const c = e.change;
+  const moved = [c.worse && `${num(c.worse)} worse`, c.new && `${num(c.new)} new`, c.better && `${num(c.better)} better`, c.gone && `${num(c.gone)} gone`].filter(Boolean);
+  const servedMove = c.served && c.served.moved !== "same" ? `achieving their goal went ${moveSaid(c.served)}` : "achieving their goal did not clearly move";
+  return `${head}\n  Since the one below: ${servedMove}; problems: ${moved.length ? moved.join(", ") : "none clearly moved"}.`;
+}
+
+export function historyText({ history: h }) {
+  const lines = ["The history of how your app behaved, newest first.", "", "Simulations:"];
+  lines.push(...(h.simulations.length ? h.simulations.map(entryLine) : ["- None has finished yet."]));
+  lines.push("", "Production, by day:");
+  lines.push(...(h.days.length ? h.days.map(entryLine) : ["- No production conversations in the last 30 days."]));
+  lines.push(`next: behavior with at: "<id>" reads one of these; with against: "previous" it says what changed persona by persona`);
+  return lines.join("\n");
+}
+
+// How much of the scope a search could reach, said every time: a search that finds nothing among
+// conversations not indexed yet has not looked at them.
+const reachSaid = (d) => (d.unindexed > 0
+  ? `${plural(d.unindexed, "conversation")} in scope ${d.unindexed === 1 ? "is" : "are"} not searchable yet and ${d.unindexed === 1 ? "is" : "are"} being indexed now.`
+  : "Every conversation in scope is searchable.");
+
+export function searchText(d, query) {
+  const hits = d.hits ?? [];
+  if (!hits.length) return `No conversation matches ${quoted(query)}. ${reachSaid(d)}\nnext: search with other words, or behavior for the whole review`;
+  const worded = hits.every((h) => h.match === "words");
+  const lines = [worded
+    ? `No conversation is about ${quoted(query)} as asked; ${plural(hits.length, "conversation")} ${hits.length === 1 ? "holds" : "hold"} its words, in the order closest to it.`
+    : `${plural(hits.length, "conversation")} ${hits.length === 1 ? "matches" : "match"} ${quoted(query)}, closest first.`];
+  // The route's share is counted in conversations, its range too.
+  if (d.share && !worded) lines.push(`About ${num(d.share.n)} of ${plural(d.share.of, "conversation")} searched are about this, ${pct(d.share)}%; between ${num(d.share.low)} and ${num(d.share.high)}.`);
+  lines.push(reachSaid(d));
+  if (hits.some((h) => h.source === "production")) lines.push("Real users' words are not shown here; each one's address opens it for the owner.");
+  hits.forEach((h, i) => {
+    if (h.source === "production") {
+      lines.push(`${i + 1}. ${short(h.conversationId)}, a real user${h.persona ? ` of "${h.persona}"` : ""}.`);
+      if (h.outcome) lines.push(`   How it ended: ${h.outcome}`);
+      if (h.open) lines.push(`   Open: ${h.open}`);
+      return;
+    }
+    lines.push(`${i + 1}. ${short(h.conversationId)}, a simulated user${h.persona ? ` of "${h.persona}"` : ""}: asked ${quoted(h.asked)}`);
+    if (h.outcome) lines.push(`   How it ended: ${h.outcome}`);
+    if (h.quote) lines.push(`   The app said: ${quoted(h.quote)}`);
+  });
+  const personas = [...new Set(hits.map((h) => h.persona).filter(Boolean))];
+  lines.push(personas.length ? `next: behavior with persona: "${personas[0]}" shows how that persona fared as a whole` : "next: behavior for the whole review");
+  return lines.join("\n");
+}

package/lib/cli.mjs

@@ -27,7 +27,7 @@ const WAITER = "run-when-up";
 // How long `run` and `verify` wait for an app started again for a change. An MCP call is cut at
 // about 60 seconds by Codex, Cursor CLI and Copilot CLI; a shell command is not.
 const RESTART_MS = { mcp: 45_000, shell: 150_000 };
-export const VERBS = ["status", "reach", "run", "run_status", "findings", "verify", "dispute", "feedback", "field_connect", "field", "world", "world_status", "test"];
+export const VERBS = ["status", "reach", "run", "run_status", "findings", "verify", "dispute", "feedback", "field_connect", "field", "world", "world_status", "test", "behavior", "search"];
 export const COMMANDS = new Set(["mcp", ...VERBS, "wait", "news", "run-status", "field-connect", "stick", "unstick", "intelligence", WAITER]);
 // A lowercase word this version has no command for, so it is never read as a connect code.
 export const unknownVerb = (word) => /^[a-z][a-z_]*$/.test(word ?? "") && !COMMANDS.has(word);
@@ -66,6 +66,7 @@ export async function main(argv, { root = process.cwd(), env = process.env, stdo
     seen: (runId) => dropNews(project, runId),
     wasRead: (runId) => wasHeard(project, runId),
     spec: npxName(cliSpec({ env })),
+    origin: origin.origin === "https://cortad.com" ? null : origin.origin,
     startApp: (args, kind) => startApp({ root, project, env, keep: mcp, children, args, kind }),
     code: makeCode({ project, root, waitMs: mcp ? RESTART_MS.mcp : RESTART_MS.shell }),
   });
@@ -130,10 +131,12 @@ const olderThan = (version, floor) => {
   for (let i = 0; i < 4; i += 1) if (a[i] !== b[i]) return a[i] < b[i];
   return false;
 };
+// Reads that start nothing on this machine, and that a connect command older than this one does not have.
+const HERE = new Set(["behavior", "search"]);
 export function asRunner(verbs, { runnerVersion, runAt: other, own = VERSION }) {
   return Object.fromEntries(VERB_NAMES.map((name) => [name, async (args) => {
     const version = runnerVersion();
-    if (!version || version === own || !RELEASE.test(version)) return verbs[name](args);
+    if (!version || version === own || !RELEASE.test(version) || HERE.has(name)) return verbs[name](args);
     const floor = CAP_FROM[name];
     const cap = floor ? cappedAt(args?.conversations).conversations : undefined;
     if (cap && olderThan(version, floor)) return { text: heldRunText(version, cap, floor), isError: true, code: "older_command" };
@@ -209,6 +212,23 @@ export function argsOf(command, rest) {
       return { ...(words.length ? { ask: words.join(" ") } : {}), ...(features?.length ? { features } : {}), ...(conversations ? { conversations: Number(conversations) } : {}), ...(account === "make" ? { account } : {}) };
     }
     case "world_status": return rest[0] ? { jobId: rest[0] } : {};
+    // `behavior [at] [--persona "<name>"] [--against previous] [--history]`.
+    case "behavior": {
+      const flag = (name) => { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; };
+      const FLAGS = ["--persona", "--against"];
+      const at = rest.find((w, i) => !w.startsWith("-") && !FLAGS.includes(rest[i - 1]));
+      const persona = flag("--persona");
+      const against = flag("--against");
+      return { ...(at ? { at } : {}), ...(persona ? { persona } : {}), ...(against ? { against } : {}), ...(rest.includes("--history") ? { history: true } : {}) };
+    }
+    // `search "<what to look for>" [--where production] [--persona "<name>"] [--limit 20]`.
+    case "search": {
+      const flag = (name) => { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; };
+      const FLAGS = ["--where", "--persona", "--limit"];
+      const words = rest.filter((w, i) => !FLAGS.includes(w) && !FLAGS.includes(rest[i - 1]));
+      const [where, persona, limit] = FLAGS.map(flag);
+      return { query: words.join(" "), ...(where ? { where } : {}), ...(persona ? { persona } : {}), ...(limit ? { limit: Number(limit) } : {}) };
+    }
     case "reach": {
       const paths = rest.filter((w) => w.startsWith("/"));
       return paths.length ? { paths } : {};

package/lib/dissection-text.mjs

@@ -119,7 +119,7 @@ const inCodeLines = (d, room) => section("Also in the code; a code review would
 const gateLines = (d, room) => section("Open gates, found by sending requests to your app's routes:", d.gates, room);
 const shortLines = (room) => [
   ...(room.leaders?.length ? [`Also to act on, each shown in full by findings: ${room.leaders.join(", ")}.`] : []),
-  ...(room.short ? [`findings shows the last ${plural(room.short, "finding")} in full${room.unlisted ? `; ${num(room.unlisted)} of them are not listed here` : ""}.`] : []),
+  ...(room.short ? [`behavior shows the last ${plural(room.short, "finding")} in full${room.unlisted ? `; ${num(room.unlisted)} of them are not listed here` : ""}.`] : []),
 ];
 
 // The first run on a repository is the baseline: who the simulated users were, what they asked for,

package/lib/doors.mjs

@@ -1,15 +1,16 @@
-// THE SIX DOORS.
+// THE SEVEN DOORS.
 //
 // Twenty tools asked a coding agent to match a description to the moment it was in, and twenty
 // descriptions with close cousins among them is a choice nobody gets right: it opened the wrong one
-// or never reached the last nine at all. These six are the questions an agent actually has.
+// or never reached the last nine at all. These seven are the questions an agent actually has.
 //
-//   status    what do I need to know about this app right now
+//   status    where do things stand: the connection, the endpoints, a run playing, what waits on the person
 //   test      test what I just built
-//   verify    did my fix hold
+//   behavior  how did the app behave with its users, at one point in time, and what changed
+//   search    find the conversations about something, by what they mean
+//   verify    did the behavior move after my fix
 //   connect   connect the live app
-//   tell      tell the Cortad team something, or say what this app counts as a good ending
-//   dispute   this check reads my app wrong
+//   tell      tell the Cortad team something, propose what counts, or say a check reads my app wrong
 //
 // The questions did not shrink. Each door answers more, and `status` with nothing said answers
 // whichever of them matters at this moment, so the common case is no choice at all.
@@ -26,35 +27,43 @@ const str = (description, extra = {}) => ({ type: "string", description, ...extr
 const readOnly = { readOnlyHint: true };
 
 // What a note to the Cortad team may be about: a door, the connect command, or the skill text.
-const ABOUT = ["status", "test", "verify", "connect", "tell", "dispute", "skill"];
+const ABOUT = ["status", "test", "behavior", "search", "verify", "connect", "tell", "skill"];
 
 // The lanes `status` opens when it is asked for one by name. Left out, it opens the one that matters.
-export const LANES = ["repository", "run", "findings", "production", "outcomes", "warehouse"];
+export const LANES = ["repository", "run", "production", "outcomes", "warehouse", "users"];
 
-// The warehouse question, unchanged: the one door parameter that is a shape rather than a word.
+// The one door parameter that is a shape rather than a word: a question Cortad compiles and pins to
+// this app. The tables are the users lane's, and the warehouse's events and readings.
+const USER_TABLES = ["conversations", "answers", "questions", "people", "profiles", "visits", "moments", "reactions"];
+const WAREHOUSE_TABLES = ["events", "readings"];
 const ASK = { type: "object", properties: {
-  table: { type: "string", enum: ["events", "readings", "reactions"] },
-  from: str("Start, ISO 8601."), to: str("End, ISO 8601, at most 90 days after from."),
-  filters: { type: "array", maxItems: 20, items: { type: "object", properties: { column: { type: "string" }, op: { type: "string", enum: ["eq", "ne", "in", "gt", "gte", "lt", "lte", "null", "not_null"] }, value: {} }, required: ["column", "op"], additionalProperties: false } },
-  group: { type: "array", maxItems: 4, items: { type: "string" }, description: "Columns, or hour or day." },
-  measures: { type: "array", minItems: 1, maxItems: 8, items: { type: "object", properties: { fn: { type: "string", enum: ["count", "count_distinct", "sum", "avg", "min", "max", "share"] }, column: { type: "string" }, equals: {}, as: { type: "string" } }, required: ["fn"], additionalProperties: false } },
+  table: { type: "string", enum: [...USER_TABLES, ...WAREHOUSE_TABLES] },
+  from: str("Start, ISO 8601. Default 30 days before to."), to: str("End, ISO 8601, at most 90 days after from. Default now."),
+  filters: { type: "array", maxItems: 20, items: { type: "object", properties: { column: { type: "string" }, op: { type: "string", enum: ["eq", "ne", "in", "gt", "gte", "lt", "lte", "contains", "null", "not_null"] }, value: {} }, required: ["column", "op"], additionalProperties: false } },
+  group: { type: "array", maxItems: 4, items: { type: "string" }, description: "Columns, or hour, day or week." },
+  measures: { type: "array", maxItems: 8, items: { type: "object", properties: { fn: { type: "string", enum: ["count", "count_distinct", "sum", "avg", "min", "max", "share", "p50", "p90"] }, column: { type: "string" }, equals: {}, as: { type: "string" } }, required: ["fn"], additionalProperties: false } },
+  columns: { type: "array", maxItems: 20, items: { type: "string" }, description: "Single rows with these columns instead of measures." },
   order: { type: "object", properties: { by: { type: "string" }, dir: { type: "string", enum: ["asc", "desc"] } }, required: ["by"], additionalProperties: false },
   limit: { type: "integer", minimum: 1, maximum: 1000 },
-}, required: ["table", "from", "to", "measures"], additionalProperties: false,
-  description: "A question over the live app's events, readings or reactions, for about warehouse. Compiled by Cortad and pinned to this app; no SQL is taken." };
+}, required: ["table"], additionalProperties: false,
+  description: "Your own question over one table that status about users lists, compiled by Cortad and pinned to this app; no SQL is taken. events and readings are the warehouse's." };
+
+const ANSWER = { type: "string", enum: ["users", "feature", "stuck", "change"], description: "A ready answer about the people using the live app. users: who they are, by user profile. feature: how people use what subject names, before you edit it. stuck: where people get stuck across every visit and conversation, with the replays to watch. change: how the same people fared after the release or time in subject." };
 
 const OUTCOME_RULE = { type: "object", properties: { kind: { type: "string", enum: ["path", "click", "event", "backend"] }, match: { type: "string", enum: ["exact", "starts", "contains"] }, value: { type: "string" }, text: { type: "string" }, selector: { type: "string" }, name: { type: "string" } }, required: ["kind"], additionalProperties: false };
 
 export const DOORS = [
   { name: "status", title: "What to know about this app right now", annotations: readOnly,
-    description: "Everything worth knowing about the AI in this repository, in one call. Said plainly with nothing asked for: a run still playing, or what failed in the one that just finished, or something going wrong in the live app, whichever is the thing to act on now. Applies at the start of a session, right after a connect, before a commit that changes prompts, tools, models or retrieval, and any time you need to know where things stand. With about, one lane in full instead.",
+    description: "Where things stand, in one call: the connection, which endpoints answer, a run playing or just finished, the live app going wrong, and what waits on the person. Applies at the start of a session, after a connect, and whenever you need it. With about, one lane in full.",
     inputSchema: { type: "object", properties: {
-      about: { type: "string", enum: LANES, description: "repository: what Cortad found in this code, each endpoint's answer, the plan. run: where a run or verify stands, and what a finished one found. findings: every failure of the last run, whole, worst first. production: the live app in numbers, what is wrong in it now and what the data says caused it. outcomes: what this app counts as a good ending and how often it is reached. warehouse: a question over the live app's own events, with ask." },
+      about: { type: "string", enum: LANES, description: "repository: what Cortad found in this code, each endpoint's answer, the plan. run: where a run or verify stands. production: the live app in numbers, what is wrong in it now and what the data says caused it. outcomes: what this app counts as a good ending and how often it is reached. warehouse: a question over the live app's own events, with ask. users: the people using the live app, their profiles, conversations, the behavioral questions and their answers, visits, what people did after each answer and reactions; with nothing else, the tables and what each column means." },
       id: str("A run's id, or a world's. Omit for the one this machine started last."),
-      show: { type: "string", enum: [...SHOW, "numbers"], description: "One list in full, in pages: for about repository, rules, standards, journeys, endpoints, trials, records or reviews, or machine, what Cortad does on this machine; for about findings, numbers, every number the run measured." },
+      show: { type: "string", enum: SHOW, description: "One list in full, in pages, for about repository: 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." },
-      days: { type: "integer", minimum: 1, maximum: 180, description: "The window for about production. Default 7." },
+      days: { type: "integer", minimum: 1, maximum: 180, description: "The window for about production, default 7, or for an answer about users, default 30 and at most 90." },
       ask: ASK,
+      answer: ANSWER,
+      subject: str("For answer feature: a page path, an app route, the part of the app that answers, or a topic. For answer change: a release, or the ISO time a change went out.", { maxLength: 200 }),
     }, additionalProperties: false } },
 
   { name: "test", title: "Test what you built",
@@ -67,11 +76,29 @@ export const DOORS = [
       account: { type: "string", enum: ["make"], description: "The person's yes to Cortad making one test account on the app's own sign-up door, for endpoints that need a signed-in user. Recorded; it starts nothing. Only with their word, said in this conversation." },
     }, additionalProperties: false } },
 
-  { name: "verify", title: "Did your fix hold",
-    description: "Replays the conversations a failure happened in, 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 be told yet with how many clean replays would decide. Conversations saved to test the fix are played once and said apart, so a fix is graded on conversations nobody read while writing it. It also says what happened the last time this same failure was made to pass, and how long that lasted. Answers within a second; status about run follows every round. Uses verify conversations from the plan, not a run.",
+  { name: "behavior", title: "How the app behaved with its users", annotations: readOnly,
+    description: "How the AI behaved with its users at one point in time, top down: how many users of how many personas achieved their goal; each persona, largest first, with who they are, how they behave, what the app did well and where it gave way, each problem with how often and the conversations that show it; the app's habits; last, where each problem comes from in the code. Default: the latest finished simulation. Applies after every run, before changing prompts, tools, models or retrieval, and when the person asks how their AI behaves.",
+    inputSchema: { type: "object", properties: {
+      at: str("A simulation's id, a commit the simulation played on, or production. Default: the latest finished simulation.", { maxLength: 64 }),
+      persona: str("One persona by name, in full, with its conversations.", { maxLength: 200 }),
+      against: str("Another point: previous, production, a simulation's id or a commit. What got better, worse, new or gone per persona, with ranges; against production, where simulated users behave unlike real ones.", { maxLength: 64 }),
+      history: { type: "boolean", description: "The log, newest first: each simulation with its commit and each production day, one line each with what changed since the one before." },
+    }, additionalProperties: false } },
+
+  { name: "search", title: "Find conversations by meaning", annotations: readOnly,
+    description: "Finds conversations about something by what they mean, across simulations and production: who asked, what, how it ended and what the app said, with how many of all conversations are about it. Applies when the person names a kind of user or a moment, or before you change how the app handles one.",
+    inputSchema: { type: "object", properties: {
+      query: str("What to look for, in words.", { maxLength: 500 }),
+      where: str("simulation, production, or one simulation's id. Default: everywhere.", { maxLength: 64 }),
+      persona: str("Only this persona's conversations, by name.", { maxLength: 200 }),
+      limit: { type: "integer", minimum: 1, maximum: 50, description: "The most conversations to return. Default 10." },
+    }, required: ["query"], additionalProperties: false } },
+
+  { name: "verify", title: "Did the behavior move",
+    description: "After a fix, replays the conversations a problem happened in, word for word, until an exact test says whether the behavior moved: gone, less often, stayed, or not yet decided with how many clean replays would decide. Saved conversations nobody read while writing the fix are played once and said apart. Answers within a second; status about run follows every round. Uses verify conversations from the plan, not a run.",
     inputSchema: { type: "object", properties: {
-      findingId: str("The failure's id, from status about findings."),
-      id: str("The run the failure came from. Omit for the latest."),
+      findingId: str("The problem's id as behavior names it, such as finding:1."),
+      id: str("The simulation the problem came from. Omit for the latest."),
     }, required: ["findingId"], additionalProperties: false } },
 
   { name: "connect", title: "Connect the live app",
@@ -81,7 +108,7 @@ export const DOORS = [
     description: "The steps to connect the live app, so Cortad sees what real users are doing as it happens and where the AI lets them down: a one-time code writes both keys into the env file, the SDK lines for this framework, the page tag, and where each conversation then appears. The owner approves it in a browser where they are signed in." },
 
   { name: "tell", title: "Tell the team",
-    description: "Say one of three things, one of them per call: a note to the Cortad team about Cortad itself, what this app counts as a good ending, or an address of yours that should receive each incident in the live app. The note is for a result that read wrong, something you needed that no door gave, a question an answer left open, or what worked; the team reads each one, and filing one is part of using Cortad. An outcome is read from the app's own code and the person approves it in the browser before any of it counts. An address is sent each incident as signed JSON, and the secret comes back once. Nothing about a run or its checks changes.",
+    description: "Say one of five things, one of them per call: a note to the Cortad team about Cortad itself; that a problem's question reads this app wrong (findingId and why); what this app counts as a good ending; behavioral questions the live app's answers should be asked; or an address of yours that should receive each incident in the live app. The note is for a result that read wrong, something you needed that no door gave, a question an answer left open, or what worked; the team reads each one. A question that reads the app wrong keeps its problem and rate as they are, and the note goes to the owner. An outcome is read from the app's own code, and a behavioral question from what behavior or status about users shows no question catches yet; the person approves each in the browser before any of it counts. An address is sent each incident as signed JSON, and the secret comes back once.",
     inputSchema: { type: "object", properties: {
       about: { type: "string", enum: ABOUT, description: "For a note: the door it is about, connect for the connect command, or skill for the instructions you were handed." },
       kind: { type: "string", enum: ["problem", "idea", "question", "praise"], description: "For a note. problem: wrong or failed; idea: something you needed; question: something an answer left open; praise: what worked." },
@@ -94,16 +121,17 @@ export const DOORS = [
           why: str("What in the code makes this an outcome.", { maxLength: 500 }),
           rules: { type: "array", minItems: 1, maxItems: 10, items: OUTCOME_RULE },
         }, required: ["name", "rules", "why"], additionalProperties: false } },
+      questions: { type: "array", maxItems: 5, description: "Behavioral questions to ask of every answer the live app gives, for the person's yes.",
+        items: { type: "object", properties: {
+          question: str("A yes-or-no question about one answer, ending in ?, where yes is what the app should do.", { maxLength: 240 }),
+          why: str("What in status about users or the code makes the case.", { maxLength: 500 }),
+          conversations: { type: "array", maxItems: 10, items: { type: "string" }, description: "Conversation ids from status about users that show it." },
+        }, required: ["question", "why"], additionalProperties: false } },
       incidentsTo: str("A public https address of yours that takes a POST and should receive each incident.", { maxLength: 500 }),
+      findingId: str("For a question that reads the app wrong: the problem's id, as behavior names it."),
+      why: str("With findingId: one or two sentences on what the question gets wrong about this app.", { maxLength: 500 }),
+      question: str("With findingId: the wording that fits this app.", { maxLength: 300 }),
     }, additionalProperties: false } },
-
-  { name: "dispute", title: "This question reads your app wrong",
-    description: "Records that a failure's question reads this app wrong, with the reason and an optional better wording. The failure and its rate stay as they are; the note goes to the owner. The honest exit when a check is measuring something this app was not built to do.",
-    inputSchema: { type: "object", properties: {
-      findingId: str("The failure's id, from status about findings."),
-      why: str("One or two sentences: what the question gets wrong about this app.", { maxLength: 500 }),
-      question: str("The wording that fits this app.", { maxLength: 300 }),
-    }, required: ["findingId", "why"], additionalProperties: false } },
 ];
 
 export const DOOR_NAMES = new Set(DOORS.map((d) => d.name));
@@ -114,7 +142,8 @@ const MOVED = {
   reach: 'test with endpoints: ["/your/path"]',
   run: "test",
   run_status: 'status about: "run"',
-  findings: 'status about: "findings"',
+  findings: "behavior",
+  dispute: "tell with findingId and why",
   feedback: "tell",
   field_connect: "connect",
   field: 'status about: "production"',
@@ -131,7 +160,7 @@ const MOVED = {
 // to run the call in (lib/cli.mjs asRunner).
 export const RETIRED = Object.keys(MOVED);
 export const VERB_NAMES = ["status", "reach", "run", "run_status", "findings", "verify", "dispute", "feedback",
-  "field_connect", "field", "world", "world_status", "test", "connect", "intelligence", "incidents", "outcomes", "subscribe", "query"];
+  "field_connect", "field", "world", "world_status", "test", "connect", "intelligence", "incidents", "outcomes", "subscribe", "query", "users", "behavior", "search"];
 
 export const movedTo = (name) => MOVED[name] ?? null;
 export const movedSaid = (name) => `${name} is now ${MOVED[name]}. This is that answer; call it that way next time.`;
@@ -143,7 +172,8 @@ export const movedSaid = (name) => `${name} is now ${MOVED[name]}. This is that
 const NEXT = {
   run_status: (id) => lane("run", id),
   world_status: (id) => lane("run", id),
-  findings: () => lane("findings"),
+  findings: () => "behavior",
+  behavior: (id) => (id ? `behavior with at: "${id}"` : "behavior"),
   run: () => "test",
   field: () => lane("production"),
   intelligence: () => lane("production"),
@@ -168,8 +198,8 @@ const idOf = (args) => args.id ?? args.jobId;
 // The lane a call is for. A parameter that belongs to one lane names it on its own, so an agent that
 // asks for a section or hands over a question lands there rather than on whatever matters now.
 const laneOf = (args) => args.about
-  ?? (args.ask ? "warehouse"
-    : args.show === "numbers" ? "findings"
+  ?? (args.answer || args.subject ? "users"
+    : args.ask ? (WAREHOUSE_TABLES.includes(args.ask.table) ? "warehouse" : "users")
     : args.show ? "repository"
     : idOf(args) ? "run"
     : args.days ? "production"
@@ -177,10 +207,10 @@ const laneOf = (args) => args.about
 
 // `verbs` is lib/verbs.mjs's object, already wrapped for an older connect command (cli.mjs asRunner).
 export function makeDoors(verbs) {
-  // With no lane asked for: the one to act on. A run playing or just finished outranks the live app,
-  // because the agent is standing in front of it; a finished run with failures is read as its
-  // failures, which is the call every agent made next anyway.
-  const now = async (page) => {
+  // With no lane asked for: the one to act on. A run playing outranks the live app, because the agent
+  // is standing in front of it; a simulation that finished is said as where things stand, with
+  // behavior as the next call, since how its users fared is that door's whole answer.
+  const now = async () => {
     const read = await verbs.status({});
     const run = read.data?.run;
     // The read is the only call that takes what the server kept to say, and it is taken once, so it
@@ -193,9 +223,10 @@ export function makeDoors(verbs) {
     // With no run to act on, a live app that is failing its people is the thing to act on.
     const idle = () => (read.data?.field?.problems ? carried(production({})) : read);
     if (!run?.jobId) return idle();
-    // Still playing, or a verify: the run's own answer. Over, with failures: the failures.
+    // Still playing, or a verify: the run's own answer. Over: where things stand, then behavior.
     if (!finished(run) || run.verify) return carried(verbs.run_status({ jobId: run.jobId }));
-    return (run.findings ?? 0) > 0 ? carried(verbs.findings({ jobId: run.jobId, ...(page ? { page } : {}) })) : idle();
+    if (!((run.findings ?? 0) > 0)) return idle();
+    return /\nnext: [^\n]*$/.test(read.text) ? read : { ...read, text: `${read.text}\nnext: behavior ${run.jobId}` };
   };
 
   // What is happening in the live app and what is wrong in it, as one answer: the numbers alone left
@@ -213,13 +244,13 @@ export function makeDoors(verbs) {
     switch (laneOf(args)) {
       case "repository": return verbs.status({ ...(args.show ? { show: args.show } : {}), ...(args.page ? { page: args.page } : {}) });
       case "run": return id ? runOrWorld(id) : verbs.run_status({});
-      case "findings": return verbs.findings({ ...(id ? { jobId: id } : {}), ...(args.show === "numbers" ? { show: "numbers" } : {}), ...(args.page ? { page: args.page } : {}) });
       case "production": return production(args);
       case "outcomes": return verbs.outcomes({});
+      case "users": return verbs.users({ ...(args.answer ? { answer: args.answer } : {}), ...(args.subject ? { subject: args.subject } : {}), ...(args.days ? { days: args.days } : {}), ...(args.ask ? { ask: args.ask } : {}) });
       case "warehouse": return args.ask
         ? verbs.query(args.ask)
-        : { text: "A warehouse question names its table (events, readings or reactions), its from and to, and at least one measure. Send it as ask.", isError: true, code: "no_ask" };
-      default: return now(args.page);
+        : { text: "A warehouse question names its table (events or readings), its from and to, and at least one measure. Send it as ask.", isError: true, code: "no_ask" };
+      default: return now();
     }
   };
 
@@ -229,21 +260,30 @@ export function makeDoors(verbs) {
     : verbs.test({ ...(args.ask ? { ask: args.ask } : {}), ...(args.conversations ? { conversations: args.conversations } : {}), ...(Array.isArray(args.features) ? { features: args.features.map(String) } : {}) }));
 
   const tell = async (args = {}) => {
+    if (args.findingId) {
+      if (!args.why) return { text: "A question that reads the app wrong is said with findingId and why: what the question gets wrong about this app.", isError: true, code: "no_why" };
+      return verbs.dispute({ findingId: String(args.findingId), why: String(args.why), ...(args.question ? { question: String(args.question) } : {}), ...(idOf(args) ? { jobId: idOf(args) } : {}) });
+    }
     if (args.outcomes) return verbs.outcomes({ proposals: args.outcomes });
+    if (args.questions) return verbs.users({ propose: args.questions });
     if (args.incidentsTo) return verbs.subscribe({ url: args.incidentsTo });
     if (!args.about || !args.kind || !args.needed) {
-      return { text: `A note names what it is about (${ABOUT.join(", ")}), its kind (problem, idea, question or praise), and what you needed. To say what counts as a good ending send outcomes instead, and to hear of incidents send incidentsTo.`, isError: true, code: "no_note" };
+      return { text: `A note names what it is about (${ABOUT.join(", ")}), its kind (problem, idea, question or praise), and what you needed. To say a question reads the app wrong send findingId and why, to say what counts as a good ending send outcomes, to propose behavioral questions send questions, and to hear of incidents send incidentsTo.`, isError: true, code: "no_note" };
     }
     return verbs.feedback({ about: args.about, kind: args.kind, needed: args.needed, ...(args.got ? { got: args.got } : {}), ...(args.tried ? { tried: args.tried } : {}) });
   };
 
+  const behavior = (args = {}) => verbs.behavior({ ...(args.at ? { at: args.at } : {}), ...(args.persona ? { persona: args.persona } : {}), ...(args.against ? { against: args.against } : {}), ...(args.history === true ? { history: true } : {}) });
+  const search = (args = {}) => verbs.search({ query: args.query, ...(args.where ? { where: args.where } : {}), ...(args.persona ? { persona: args.persona } : {}), ...(Number.isSafeInteger(args.limit) ? { limit: args.limit } : {}) });
+
   return {
     status,
     test,
+    behavior,
+    search,
     verify: (args = {}) => verbs.verify({ findingId: args.findingId, ...(idOf(args) ? { jobId: idOf(args) } : {}) }),
     connect: (args = {}) => verbs.connect(typeof args.site === "string" && args.site ? { site: args.site } : {}),
     tell,
-    dispute: (args = {}) => verbs.dispute(args),
   };
 }