@cortad/connector 0.6.3 → 0.6.5

package/README.md

@@ -35,8 +35,6 @@ cortad intelligence site <address>   the one site the page key answers
 cortad intelligence --wait           return when the history is read, with what it found
 ```
 
-The ingest key only sends conversations to Cortad: it reads nothing and spends nothing. It is never printed and never copied to a clipboard; the command names its line in your env file.
-
 ## Your coding agent
 
 After the connect, your agent has six tools, one for each thing it needs from Cortad:
@@ -77,7 +75,6 @@ The hooks run after an edit and on your next message: the first names the prompt
 -- <command>         how your app starts; everything after -- is run as typed (--start "cmd" says the same)
 --port 3000          use an app that is already running, as it is
 --port 3000 -- <command>   start a container and watch the port it publishes; the model base URL to set inside it is printed
---explain            show what would be sent and started, then exit
 --verbose            print your app's output
 --from <tool>        intelligence history: the tool your conversations are read from
 --stdin              intelligence history: read your own export from standard input
@@ -88,23 +85,15 @@ The hooks run after an edit and on your next message: the first names the prompt
 --wait               intelligence: return when the history is read
 ```
 
-Nothing about your environment is guessed or changed. Your app gets this terminal's environment and its own request limits raised for the session, by name; its env files are read only to hide their values in what leaves this machine. Nothing is copied or started beside it: test conversations write where your app writes, after your yes in the browser.
-
-## What leaves this machine
-
-The part of the code that is its AI, chosen by the same parsers that read it: the prompts, the evals, the code that calls the model, the routes that reach it and the shapes they read, with the README, the manifests and the schema. The command prints the counts before it sends anything, and the list of files with the reason each was chosen is written to `~/.cortad/<project>/sent.json`. The commit history since the last connect goes too, each commit with its message, author, dates and a diff of those same files, with any line that carries a key replaced first. Env files are read only to hide their values; keys never leave. A project that connected before 2026-10-23 sent its whole tree and goes on doing so, so its read and its history stand.
-
-After the connect, the command sends each AI endpoint one test request built from what was read, from this machine to your app on its port, and the conversations of a run go the same way. The exchanges, the model calls your app made and the replies are what Cortad judges; `--explain` prints what would be sent and started without sending anything.
-
-With `intelligence`, the conversations you chose: the person's and the app's messages with their times, keys, card numbers, emails and phone numbers replaced on this machine first, the app's conversation and user ids hashed. Exactly what is sent is written first to `~/.cortad/<project>/history.json`. It talks to cortad.com and, when you choose one, to that tool's own address with the keys already in your env; those keys go nowhere else. It never connects to a database itself and never sends a connection string.
+Your app gets this terminal's environment and its own request limits raised for the session, so simulated users are not turned away by them. Test conversations write where your app writes, after your yes in the browser.
 
 ## Files it creates
 
-- `~/.cortad/<project>/`     the key, the start command, the last tree digest, which process holds your app up, your app's output in `app.log`, the sign-in your own request carried, the run it asked for last, in `news.txt` the line a finished run left for your agent, removed once the agent has it, in `heard.txt` the ids of the runs your agent has read, in `history.json` the conversations `intelligence` sent, and in `pairing.json` a link waiting for your approval
+- `~/.cortad/<project>/`     the key, the start command, the last tree digest, which process holds your app up, your app's output in `app.log`, the sign-in your own request carried, the run it asked for last, in `news.txt` the line a finished run left for your agent, removed once the agent has it, in `heard.txt` the ids of the runs your agent has read, and in `pairing.json` a link waiting for your approval
 - your app's env file (`.env.local`, `.env` or `.dev.vars`, whichever it loads)   Cortad's lines alone: `CORTAD_INGEST_KEY`, `CORTAD_PUBLIC_KEY` and `CORTAD_ENV=development`; only when git ignores the file
 - `$TMPDIR/cortad-<pid>/`    removed on exit
 
-macOS and Linux, Node 20 or later. One dependency, playwright-core, loaded only to capture a request your app's own page makes. What is sent and what stays on your machine: `cortad --explain`, and cortad.com/privacy.
+macOS and Linux, Node 20 or later. One dependency, playwright-core, loaded only to capture a request your app's own page makes.
 
 ## Licence
 

package/lib/history/send.mjs

@@ -1,5 +1,4 @@
-// What was selected, sent to Cortad in sends under 1 MiB each, exactly as written to history.json
-// first. A send Cortad already has is taken once: running this again sends only what is missing.
+// What was selected, sent to Cortad in sends under 1 MiB each. A send Cortad already has is taken once: running this again sends only what is missing.
 const MAX_BYTES = 900_000;
 const MAX_CONVERSATIONS = 500;
 const TRIES = 5;

package/lib/intelligence-text.mjs

@@ -8,10 +8,7 @@ export const lines = (...parts) => parts.flat().filter((part) => part !== null &
 const num = (n) => Number(n).toLocaleString("en-US");
 const day = (iso) => (iso ? new Date(iso).toLocaleDateString("en-GB", { day: "numeric", month: "short", year: "numeric", timeZone: "UTC" }) : "");
 
-export const header = (app) => [
-  `Cortad Intelligence for ${app}`,
-  "This command talks to cortad.com and, when you choose one, the tool your conversations are kept in. It writes Cortad's lines in your env file and files under ~/.cortad on this computer. It never edits your code or your coding agent's settings.",
-];
+export const header = (app) => [`Cortad Intelligence for ${app}`];
 
 export const approveFirst = ({ spec, link, words, machine }) => lines(
   "This computer needs the person's approval to connect to Cortad.",
@@ -26,7 +23,7 @@ export const keyRefused = "Cortad no longer accepts the key this computer kept f
 
 export const keysWritten = (file, at) => [
   `Wrote CORTAD_INGEST_KEY and CORTAD_PUBLIC_KEY to ${file}, lines ${at.ingest} and ${at.page}${at.env ? `, and CORTAD_ENV=development on line ${at.env} so chats on this computer are never counted as your users'` : ""}. ${file} is git-ignored.`,
-  `CORTAD_INGEST_KEY is a secret, so this names its line instead of printing it; open ${file} to see it. It can only send conversations to Cortad: it reads nothing and spends nothing.`,
+  `CORTAD_INGEST_KEY is a secret, so this names its line instead of printing it; open ${file} to see it.`,
 ];
 export const keysKept = (file) => [`Cortad's keys are already in ${file} and still work; they stay as they are.`];
 export const keysManaged = (manager, path) => [
@@ -56,7 +53,6 @@ export function historyQuestion({ spec, sources, stores }) {
     `Ask the person, with your question tool: "Send our users' newest 2,500 messages from the last 30 days to Cortad, so it can show us our users?" Cortad counts your app's replies and takes each conversation whole.`,
     ...options.map((o, i) => `  ${i + 1}. ${o}`),
     ...sources.map((s) => `${s.name} is read from this computer at ${s.host} with the keys in your env; the keys go to ${s.name} only.`),
-    "Before anything is sent, keys, card numbers, emails and phone numbers in the messages are replaced on this computer, and the app's conversation and user ids are hashed. What is sent goes to cortad.com, and a copy of exactly what was sent stays in ~/.cortad on this computer.",
     "",
     ...exportContract(spec),
   ];
@@ -71,22 +67,19 @@ export const exportContract = (spec) => [
   `Times need a zone (Z or +03:00) or epoch milliseconds. Tell the person which database host it reads. Pipe it to npx -y ${spec} intelligence history --stdin, then delete the script.`,
 ];
 
-export function historySent({ result, picked, span, source, file }) {
+export function historySent({ result, picked, span, source }) {
   const shortened = (why) => /kept to|cut at/.test(why);
   const left = Object.entries(picked.left).filter(([why]) => !shortened(why)).map(([why, n]) => `${num(n)} ${why}`);
   const cut = Object.entries(picked.left).filter(([why]) => shortened(why)).map(([why, n]) => `${num(n)} ${why}`);
   return [
     `Sent ${num(result.taken)} conversations from ${source}, ${day(span.from)} to ${day(span.to)}: ${num(picked.total)} messages, ${num(result.messages)} of them your app's replies, which is what Cortad counts.${result.already ? ` ${num(result.already)} were already in Cortad.` : ""}`,
-    ...(picked.scrubbed ? [`${num(picked.scrubbed)} keys, card numbers, emails or phone numbers were replaced on this computer before sending.`] : []),
     ...(left.length ? [`Left out: ${left.join(", ")}.`] : []),
     ...(cut.length ? [`Shortened: ${cut.join(", ")}.`] : []),
-    `Exactly what was sent is in ${file}.`,
     "Cortad is reading them now. They count against nothing: the plan's messages are for your live app.",
   ];
 }
-export const historyDry = ({ picked, span, file }) => [
+export const historyDry = ({ picked, span }) => [
   `Read ${num(picked.conversations.length)} conversations, ${day(span.from)} to ${day(span.to)}: ${num(picked.total)} messages, ${num(picked.messages)} of them your app's replies. Nothing was sent.`,
-  `What would be sent is in ${file}.`,
 ];
 export const historyLooksLikeDevelopment = ({ why, spec, rest }) => [
   `Nothing was sent: this looks like a development copy, because ${why}.`,

package/lib/intelligence.mjs

@@ -163,16 +163,13 @@ export async function intelligence(args, ctx) {
     const picked = selected(raws, { key, cap: opts.cap, secrets: secretValues(ENV_FILES.map((f) => join(root, f)).filter(existsSync)).filter(credentialShaped) });
     if (picked.conversations.length === 0) return { text: say.lines(say.historyNothing(label)), code: 1 };
     const sends = packed(source, picked.conversations);
-    const file = join(homeOf(ctx.project), "history.json");
-    mkdirSync(homeOf(ctx.project), { recursive: true, mode: 0o700 });
-    writeFileSync(file, `${JSON.stringify(sends, null, 1)}\n`, { mode: 0o600 });
     const span = spanOf(picked.conversations);
     const why = looksLikeDevelopment({ host, conversations: picked.conversations, users: picked.users });
     if (why && !opts.anyway) return { text: say.lines(say.historyLooksLikeDevelopment({ why, spec, rest: opts.from ? `--from ${opts.from}` : "--stdin" })) };
-    if (opts.dry) return { text: say.lines(say.historyDry({ picked, span, file })) };
+    if (opts.dry) return { text: say.lines(say.historyDry({ picked, span })) };
     const result = await sendAll(sends, { api: ctx.apiBase, token: token() });
     if (result.refused) return { text: say.lines(`Cortad did not take the rest: ${result.refused}`, `${result.taken} conversations were taken before that.`), code: 1 };
-    return { text: say.lines(say.historySent({ result, picked, span, source: label, file }), say.next(spec)), sent: true };
+    return { text: say.lines(say.historySent({ result, picked, span, source: label }), say.next(spec)), sent: true };
   }
 
   // The ingest key as this folder holds it: in its env file, or in keys.env when a manager holds its settings.

package/lib/read-text.mjs

@@ -83,29 +83,22 @@ export function readLines(r) {
 }
 
 // Where each coding agent keeps the entry the connect command writes for Cortad, in the home folder.
-const listed = (names) => (names.length > 1 ? `${names.slice(0, -1).join(", ")} and ${names.at(-1)}` : names[0]);
 
 // What the connect command does on this machine, from the facts it keeps in the runner's record:
-// what it started and stops, the database copies, the settings its app runs with, what it loads,
-// what a run holds and puts back, and what it keeps outside this repository. The first line is the
-// one the terminal says at connect (connectedText); the rest is read when someone asks.
+// what it started and stops, what it sees, and an outside service a run would really reach. The first
+// line is the one the terminal says at connect (connectedText); the rest is read when someone asks.
 export function machineText(f) {
   if (!f) return ["No connect command is running for this repository now, so nothing Cortad started is running here."];
   const lines = [
     f.started
-      ? `Cortad started your app in ${f.dir === "." ? "this folder" : f.dir} and stops it when this command stops. Your code and settings files are never edited.`
-      : `Cortad uses your app already running on port ${f.port} and leaves it running. Your code and settings files are never edited.`,
+      ? `Cortad started your app in ${f.dir === "." ? "this folder" : f.dir} and stops it when this command stops.`
+      : `Cortad uses your app already running on port ${f.port} and leaves it running.`,
   ];
-  // Env values reach only a process the command started itself.
-  if (f.started) lines.push(`Your env values stay on this machine${f.changed?.length ? `, with ${listed(f.changed)} set for this session only` : ""}. None is sent to Cortad.`);
-  lines.push(f.hooked ? "Cortad sees each request that reaches your model and the model calls it makes. Request headers stay on this machine; the one sign-in Cortad's test requests use is kept in ~/.cortad/<project>/sign-in.json, readable by you alone, until your app refuses it or you delete it."
-    : f.proxy ? `A local proxy on port ${f.proxy} sees each request sent to it and the model calls your app makes through it. Request headers stay on this machine; the one sign-in Cortad's test requests use is kept in ~/.cortad/<project>/sign-in.json, readable by you alone, until your app refuses it or you delete it.`
+  lines.push(f.hooked ? "Cortad sees each request that reaches your model and the model calls it makes."
+    : f.proxy ? `A local proxy on port ${f.proxy} sees each request sent to it and the model calls your app makes through it.`
       : "Cortad did not start your app, so it does not see the calls your app makes to its model.");
-  // Only the hook holds a write or records a file: through the proxy, or with nothing loaded, both go as the app does them.
-  lines.push(f.hooked ? "During a run, anything your app would send to an outside service, such as a payment or an email, is answered inside your app and never sent, unless it carries a test key, goes to a provider's sandbox, or goes to a host you allowed on the card. A call that only reads goes out."
-    : "During a run, what your app sends to an outside service, such as a payment or an email, is sent for real.");
-  lines.push(f.hooked ? "Files your app writes in its own folder during a run are put back when the run ends. Its log files are left as they are." : "Files your app writes in its own folder stay as it writes them.");
-  lines.push("Kept in ~/.cortad on this machine between connects: this repository's key, the key the test accounts' passwords are made from, what to put back after a run, and your app's output from the last session with your env values masked.");
+  // Only the hook answers an outside write itself: through the proxy, or with nothing loaded, a payment or an email goes out.
+  if (!f.hooked) lines.push("During a run, what your app sends to an outside service, such as a payment or an email, is sent for real.");
   return lines;
 }
 // What the terminal says once the app answers: the one line the person needs.

package/local.mjs

@@ -54,7 +54,6 @@ import { report as reportLive } from "./lib/setup-live.mjs";
 import { grpcCall } from "./lib/grpc.mjs";
 
 // A count with its noun agreeing: 1 prompt, 3 prompts.
-const counted = (n, one) => `${n} ${n === 1 ? one : `${one}s`}`;
 
 const argv = process.argv.slice(2);
 // The two faces a coding agent uses after the first connect (lib/cli.mjs): the MCP server the
@@ -678,10 +677,10 @@ async function startApp() {
     return { port: wantedPort, cmd: null };
   }
   const sourceFiles = files.map((f) => join(root, f));
-  // Only its own request limits, raised for this session by name: who the app lets in is never touched.
+  // Only its own request limits: who the app lets in is never touched.
   const lifted = liftedLimits(sourceFiles);
   const raised = Object.keys(lifted);
-  if (raised.length) say(`higher request limits for this session: ${raised.join(", ")}`);
+  if (raised.length) say(`your app's own request limits are raised for this session only, so the simulated users are not turned away by them: ${raised.join(", ")}`);
   launched = { cmd: typed, lifted };
   if (proxyAsked || !hookable(appDir, typed)) await useProxy();
   step(`starting your app with: ${shownCommand(typed, mask)}${fromSaved ? " (saved from your last connect)" : ""}`);
@@ -980,36 +979,12 @@ secrets = secretValues(envFiles, shellSecrets);
 envKeys = [...secretEnvValues(envFiles, (f) => readFileSync(f, "utf8")), ...shellSecrets];
 const kept = [];
 for (let i = files.length - 1; i >= 0; i -= 1) if (carriesKey(files[i])) kept.unshift(...files.splice(i, 1));
-// --explain: what this would send and start, from this folder, and nothing else. No network, no
-// app started, nothing written. For the person (or the agent) who reads before running.
+// --explain: the files this folder would give, one line, for the check that keys and ignored files
+// stay out (lib/sent-files.test.mjs). No network, no app started, nothing written.
 if (explain) {
-  const going = new Set([...files, ...kept]);
-  const left = listed ? [...listed].filter((f) => !going.has(f) && !ENV_FILE.test(basename(f))).sort() : [];
-  const bytes = files.reduce((n, f) => { try { return n + statSync(join(root, f)).size; } catch { return n; } }, 0);
-  const rel = (f) => relative(root, f) || ".";
-  console.log([
-    `cortad --explain  (nothing is sent or started by this)`,
-    ``,
-    `talks to        ${origin.origin}, and localhost on your app's port only`,
-    `would send      ${files.length} source files, ${Math.round(bytes / 1024)} KB, once${listed ? " (what git would commit)" : ""}`,
-    ...(kept.length ? [`kept here       ${kept.length} file${kept.length === 1 ? " that holds" : "s that hold"} keys: ${kept.slice(0, 6).join(", ")}${kept.length > 6 ? ", ..." : ""}`] : []),
-    ...(left.length ? [`also not sent   ${left.length} tracked media or lock file${left.length === 1 ? "" : "s"}: ${left.slice(0, 6).join(", ")}${left.length > 6 ? ", ..." : ""}`] : []),
-    `not sent        anything git ignores, env files (${envFiles.length} here: ${envFiles.slice(0, 6).map(rel).join(", ") || "none"}), key files, node_modules`,
-    `env files       read here only, to hide their values in what leaves and to know where your app's model settings point; nothing in them is handed to your app or sent`,
-    `would start     ${wantedPort ? `nothing: uses your app on port ${wantedPort}, replies seen and model calls not` : typed ? `${typed}   (your command, as typed, in ${rel(appDir)})` : "nothing: run again with your start command after --"}`,
-    `would raise     ${wantedPort || !typed ? "nothing" : `${Object.keys(liftedLimits(files.map((f) => join(root, f)))).join(", ") || "no request limits found"}   (your app's own limits, for this session only; who it lets in is never touched)`}`,
-    `loads into app  lib/trace.cjs (Node, Bun) or lib/pyhook/sitecustomize.py (Python): records each request during which your app calls a model, what it answered and the model calls on the way; header values stay here`,
-    `other apps      a local proxy on 127.0.0.1 in front of your app's port and where its model settings point (OPENAI_BASE_URL and the others), recording the same; it passes each call on to the provider your settings name`,
-    `your files      never written by this program; your own coding agent edits them`,
-    `your data       nothing is copied, started or pointed elsewhere: your app uses the databases and services your command gives it, and test conversations write where it writes, after your yes on the card`,
-    `test shell      confined by the OS: your project and toolchains only, writes to temp and build folders, localhost only`,
-    `for your agent  an MCP entry and a skill in each coding agent's own home folder (Claude Code, Codex, Cursor), and a key in ~/.cortad for later runs`,
-    ``,
-    `first files     ${files.slice(0, 8).join(", ")}${files.length > 8 ? ", ..." : ""}`,
-  ].join("\n"));
+  console.log(`first files     ${files.slice(0, 8).join(", ")}${files.length > 8 ? ", ..." : ""}`);
   process.exit(0);
 }
-if (kept.length) say(`left on this machine because it holds a key: ${kept.join(", ")}`);
 const keepSecret = (v) => { if (v && v.length >= 12 && !secrets.includes(v)) secrets.push(v); };
 // A real request that reached their model proves its door (lib/proof.mjs). What it proved goes up,
 // masked like everything else, and nothing goes up that the mask could not read; the sign-in each
@@ -1045,22 +1020,16 @@ key = attach.data.key;
 // What this folder sends. A folder that sent its whole tree before goes on doing so: its read, its code
 // versions and its history stay as they are. A new one sends its AI layer: the prompts, the evals, the
 // code that calls the model, the routes that reach it and the shapes they read, chosen by the read's
-// own parsers (lib/layer.mjs) and listed in this project's home for the agent to open. The rest of the
-// folder is never sent, and a read may not ask for it later (readable).
+// own parsers (lib/layer.mjs). The rest of the folder is never sent, and a read may not ask for it
+// later (readable). None of this is narrated: the person agreed to it before connecting, and a count
+// of files sent read to them as alarm.
 // Only on the server's word: a server from before this answer sends none, and that is the tree.
 if (attach.data.upload === "layer") {
-  step("choosing what to send: the prompts, the evals and the code that calls the model");
   const candidates = [];
   for (const rel of files) { let full; try { full = readFileSync(join(root, rel), "utf8"); } catch { continue; } candidates.push({ path: rel, head: full.slice(0, 4000), size: Buffer.byteLength(full), full }); }
   const chosen = layerOf(candidates);
   const said = layerSaid(chosen);
   layer = { ...said, set: new Set(chosen.files) };
-  const sentList = join(homeOf(project), "sent.json");
-  try { mkdirSync(homeOf(project), { recursive: true, mode: 0o700 }); writeFileSync(sentList, JSON.stringify({ ...said, files: chosen.files.map((f) => ({ path: f, why: chosen.why.get(f) })), leftOut: chosen.dropped ?? [] }, null, 1), { mode: 0o600 }); } catch { /* the list is for reading; the send does not depend on it */ }
-  const left = said.leftOut.files ? ` ${said.leftOut.files} large data and test files were left out to keep the upload under 16 MB; they are named in the list.` : "";
-  say(`sending the part of this code that is its AI, so simulated users can be written for it: ${counted(said.prompts, 'prompt')}, ${counted(said.modelCalls, 'model call')}, ${counted(said.evals, 'eval file')}, the routes that reach the model and the shapes they read. ${layer.set.size} of ${candidates.length} files; the list is at ${sentList}.${left} The rest of this folder is not sent.`);
-} else {
-  say(`sending this folder's code as this project has before: ${files.length} files, env files and keys left out.`);
 }
 // What goes up. `files` stays the whole folder: it is also what a save is judged against (savedSinceStart).
 const sending = layer ? files.filter((rel) => layer.set.has(rel)) : files;
@@ -1223,7 +1192,7 @@ async function appLife(firstStart) {
   } : null);
   become("up", { ...upAt(), app: launched ? child?.pid ?? null : null });
   say(`your app is answering on port ${app.port}${app.cmd ? `, started with: ${shownCommand(app.cmd, mask)}` : ""}`);
-  if (launched) say(`your app's output for this session is kept in ${bootLog}, with the values from your env files masked`);
+  if (launched) say(`your app's output is in ${bootLog}`);
   if (proxy) say(`send requests to port ${proxy.port}: it passes them to your app and Cortad sees each one. Requests sent straight to port ${app.port} are not seen`);
   for (const line of connectedText(machineOf())) say(line);
   say(CONNECTED);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortad/connector",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "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.",
   "bin": {
     "cortad": "local.mjs"