cortad 0.3.1-rc.14 → 0.3.1-rc.16

package/lib/contact-text.mjs

@@ -97,8 +97,12 @@ function readyLine(r) {
     ? `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 usd = (x) => `$${x.toFixed(2)}`;
-  const cost = has(r.usd) && `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" : ""}`;
-  const parts = [fit, has(r.replies) && `about ${plural(r.replies, "reply", "replies")}`, time, cost].filter(Boolean);
+  // 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}`;
 }

package/lib/proof.mjs

@@ -411,6 +411,25 @@ function carrierOf(earlier, later, ask, door) {
   return { carrier: "none", key: null };
 }
 
+// Body fields a later request sent back with a value the reply to an earlier one handed out, which
+// that earlier request had not sent there: AI Answers signs each conversation's history and refuses a
+// follow-up without the signature its last reply carried. A trial sends back what its own last reply
+// handed out. The conversation's own carrier is the session's, not one of these.
+function echoesOf(exchanges, ask, session) {
+  const out = new Set();
+  for (let i = 1; i < exchanges.length; i++) {
+    for (const l of leaves(bodyOf(exchanges[i]) ?? {})) {
+      const at = l.at.join(".");
+      if (inList(l.at) || fieldOf(l.at) === ask?.field || (session.carrier === "body" && at === session.key)) continue;
+      if (!/^\S{6,}$/.test(l.value) || !(/\d/.test(l.value) || l.value.length >= 16)) continue;
+      const handed = exchanges.slice(0, i).some((earlier) => norm(earlier.reply).includes(norm(l.value))
+        && leaves(bodyOf(earlier) ?? {}).find((e) => e.at.join(".") === at)?.value !== l.value);
+      if (handed) out.add(at);
+    }
+  }
+  return [...out];
+}
+
 // Held when a later prompt carried an earlier exchange's words. A body that carried them in a field
 // other than its own ask holds the conversation itself; otherwise what stayed the same carries it.
 // `tried`: a later request went on from an earlier one (it sent back what that one was handed, or
@@ -660,9 +679,14 @@ export function proofOf(exchanges, door, { find = () => null, base = "" } = {})
   // A reply cut short, by either side, is not the reply: the latest whole one stands.
   const uncut = exchanges.findLastIndex((ex) => !ex.cut);
   const shown = uncut < 0 ? exchanges.length - 1 : uncut;
-  // The person's own request is the shape trials take; ours only when there is none.
-  const shape = latest;
   const session = sessionOf(exchanges, ask, door);
+  // The person's own request is the shape trials take; ours only when there is none. Where the history
+  // carries the conversation, one whose history holds turns: a first message's empty list says nothing
+  // of how the app writes a turn, and AI Answers' follow-ups went out as {role:"assistant"} where it
+  // writes and signs {sender:"ai"}, refused 403 every one.
+  const turnsIn = (ex) => { const list = String(session.key ?? "").split(".").reduce((v, k) => v?.[k], bodyOf(ex)); return Array.isArray(list) && list.length > 0; };
+  const shape = session.carrier === "history" ? exchanges.findLast(turnsIn) ?? latest : latest;
+  const echoes = echoesOf(exchanges, ask, session);
   const metered = exchanges.filter((ex) => generation(ex).some((c) => c.usage));
   const tokens = (key) => median(metered.map((ex) => generation(ex).reduce((n, c) => n + (Number(c[key]) || 0), 0)));
   // The model that answered names the endpoint's model; the one asked for only when no other answered.
@@ -688,6 +712,7 @@ export function proofOf(exchanges, door, { find = () => null, base = "" } = {})
       askField: ask?.field ?? null,
       ...(ask?.appFields.length ? { appFields: ask.appFields } : {}),
       session,
+      ...(echoes.length ? { echoes } : {}),
       replyPath: replies[shown].path,
       stream: replies[shown].stream,
       modelCalls: median(exchanges.map((ex) => generation(ex).length)) ?? 0,
@@ -745,7 +770,7 @@ export function canaryOf(exchanges, proof, found = null, own = []) {
   if (!sent) return null;
   // The fact went nowhere in the request: the endpoint has no place for a person's words.
   const nonce = NONCE.exec(norm(sent.a1.body))?.[0];
-  if (!nonce) return { n: Number(n), passed: false, problems: [{ kind: "ask-not-in-turn", side: "ours", said: "This endpoint's request has no place for a person's message, so a trial's words would reach nothing." }] };
+  if (!nonce) return { n: Number(n), passed: false, problems: [{ kind: "ask-nowhere", side: "ours", said: "This endpoint's request has no place for a person's message, so a trial's words would reach nothing." }] };
   const { a1, a2, b1 } = sent;
   const problems = [];
   const add = (kind, side, said) => problems.push({ kind, side, said });

package/lib/stores.mjs

@@ -237,9 +237,13 @@ const HELD = {
   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).
 const heldWhy = (s, why, tool) => {
   const [reason, fix] = (HELD[why] ?? HELD.other)(s, tool);
-  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.`;
+  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}`;
 };
 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

@@ -30,6 +30,8 @@ export const finished = (run) => Boolean(run) && (run.finished ?? DONE.has(run.s
 export function statusText(d) {
   const lines = [];
   if (d.repository?.name) lines.push(`Cortad · ${d.repository.name}`);
+  // What changed since the last status call, first: the read landing, endpoints proven, a run.
+  if (d.news?.length) lines.push("New since your last call:", ...d.news.map((n) => `  ${n}`));
   const plan = planLine(d.plan);
   if (plan) lines.push(plan);
   lines.push(...appLines(d));

package/local.mjs

@@ -12,6 +12,7 @@
 // on with the key this connect leaves in ~/.cortad. Nothing here touches git. Your environment
 // never leaves this machine. Ctrl-C ends everything.
 
+import { storesOf } from "./lib/stores.mjs";
 import { notAnApp, withoutStores } from "./lib/app-port.mjs";
 import { holdsKeys, secretEnvValues } from "./lib/keys.mjs";
 import { spawn, execFile, execFileSync } from "node:child_process";
@@ -253,6 +254,8 @@ let secrets = [];
 const LATER_HEADER = "x-cortad-answer", LATER_MISSED = "x-cortad-later", LATER_MARGIN_MS = 5_000;
 // The cookies each trial's own turns were handed, newest trials kept.
 const trialJars = new Map();
+// Endpoints that refused a new visitor: their trials carry the person's own session.
+const ownSession = new Set();
 const TRIAL_JARS = 500;
 let identities = null;
 let capture = null;
@@ -411,9 +414,25 @@ async function verb(job) {
       // a reply is waited on for three of them. A run that says nothing gets the old 170 seconds.
       const holdMs = Math.min(Math.max(Number(b.waitMs) || 170_000, 1_000), 630_000);
       const began = Date.now();
+      // The trial's own cookies take the place of the captured ones of the same name: a session your
+      // app keys its conversation on is this trial's, never the one every trial was handed at capture.
+      const cookieAt = Object.keys(headers).find((k) => k.toLowerCase() === "cookie");
+      const { [cookieAt ?? ""]: given = "", ...cookieless } = headers;
+      const cookie = () => [...new Map([...given.split(/;\s*/), ...jar.split(/;\s*/)].filter(Boolean).map((pair) => [pair.split("=")[0].trim(), pair])).values()].join("; ");
+      // A cookie your app hands any new visitor is that visitor's session: each trial asks for its own,
+      // so one trial's answer in progress never holds another's (AI Answers answers one at a time per
+      // visitor, and every trial carried the agent's one session). An endpoint that refuses a new
+      // visitor keeps the person's session for this trial and every later one.
+      const door = `${method} ${path.split("?")[0]}`;
+      const fresh = Boolean(trial && given && !trialJars.has(trial) && !ownSession.has(door));
+      const visitor = async () => {
+        const res = await fetch(url, { method: "GET", headers: cookieless, redirect: "manual", signal: AbortSignal.any([letGo, AbortSignal.timeout(15_000)]) }).catch(() => null);
+        await res?.arrayBuffer().catch(() => null);
+        return (res?.headers.getSetCookie?.() ?? []).map((c) => c.split(";")[0]).filter(Boolean).join("; ");
+      };
       const sent = (at, over = {}) => fetch(at, {
         ...init, ...over,
-        headers: { ...headers, ...(over.headers ?? {}), ...(jar ? { cookie: [headers.cookie, jar].filter(Boolean).join("; ") } : {}) },
+        headers: { ...(jar ? cookieless : headers), ...(over.headers ?? {}), ...(jar ? { cookie: cookie() } : {}) },
         signal: AbortSignal.any([letGo, AbortSignal.timeout(holdMs)]),
       });
       const keep = (res) => {
@@ -433,8 +452,17 @@ async function verb(job) {
         }
       };
       const ask = async () => {
+        if (fresh) { jar = await visitor(); if (jar) trialJars.set(trial, jar); }
         let res = await sent(url);
         keep(res);
+        if (fresh && jar && (res.status === 401 || res.status === 403)) {
+          ownSession.add(door);
+          jar = "";
+          trialJars.delete(trial);
+          await res.arrayBuffer().catch(() => null);
+          res = await sent(url);
+          keep(res);
+        }
         if (method !== "GET" && sentBack(res)) { await warm(); if (jar) res = await sent(url); }
         const buf = Buffer.from(await res.arrayBuffer());
         // An OpenAPI document can run to megabytes; the caller asks for it whole.
@@ -508,6 +536,8 @@ async function verb(job) {
     }
     // The person changed what they said yes to while this command runs.
     case "consent": await allowOutbound(b); return { ok: true };
+    // A line for the agent reading this terminal: the read of the code landing, said the moment it does.
+    case "say": { const line = String(b.line ?? "").replace(/\s+/g, " ").trim().slice(0, 400); if (line) say(line); return { ok: true }; }
     case "restart": return restartApp();
     case "inventory": return inventoryOf(b.probe && typeof b.probe === "object" ? b.probe : {});
     // Your own pages, read here rather than in a world's shell: that shell is sealed away from
@@ -861,7 +891,10 @@ async function start(waitMs, tries = 3) {
   try { markRun(writesDirOf(homeOf(projectOf(root))), "session", { keep: true }); } catch { /* the app's writes go unrecorded */ }
   // Taken before the app reads a file: a save after this moment is a change it has not loaded.
   const note = { own: true, at: Date.now(), reloads: RELOADER.test(commandText(cmd, appDir)), answered: false };
-  note.files = sourceOf(root, files);
+  // The settings files count as what it loaded: an env file is rarely tracked, and an agent's edit to
+  // one left the app on the old settings until the command was started again (ulaim, 2026-10-01).
+  note.files = { ...sourceOf(root, files), ...sourceOf(root, envFiles.filter((f) => !/\.(example|sample)$/.test(f)).map((f) => relative(root, f))) };
+  storesAt ??= storesNamed();
   loaded = note;
   const copies = await keeping.env(true);
   await allowOutbound();
@@ -957,10 +990,21 @@ const savedSinceStart = () => Boolean(loaded?.files) && changesOf({
 // Every save that changes what your app runs starts it again, when it does not reload by itself: an
 // agent that saved a fix and asked the app eight seconds later was answered by the old code. Looked
 // at again after each restart, for a save made while it was under way.
+// The stores the settings name, as copies are made of them: a change here is a change of what the app
+// writes into, so its copies and holds are made again for the new settings, and said again.
+const storesNamed = () => { try { return JSON.stringify(storesOf({ ...envExports(envFiles), ...process.env }).map((s) => [s.engine, s.host, s.port, s.db, s.names])); } catch { return ""; } };
+let storesAt = null;
 async function restartOnSave() {
   while (!closing) {
     await sourceChanged();
-    while (!closing && launched && child && !appGone && !loaded?.reloads && savedSinceStart()) await restartApp();
+    while (!closing && launched && child && !appGone && !loaded?.reloads && savedSinceStart()) {
+      const named = storesNamed();
+      const moved = storesAt !== null && named !== storesAt;
+      storesAt = named;
+      if (moved) await keeping.forget().catch(() => {});
+      await restartApp(moved ? "starting your app again on the settings you changed, with its data copied again for them" : undefined);
+      if (moved) await announce().catch(() => null);
+    }
   }
 }
 async function restartNow() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortad",
-  "version": "0.3.1-rc.14",
+  "version": "0.3.1-rc.16",
   "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"