@parley-im/parley 0.1.1 → 0.2.0

package/dist/db.js

@@ -1,16 +1,17 @@
 import { DatabaseSync } from "node:sqlite";
 import { randomBytes } from "node:crypto";
-import { readdirSync, rmSync } from "node:fs";
-import { basename, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
 import { paths, ensureHome } from "./config.js";
 import { newKey } from "./seal.js";
+import { record } from "./transcript.js";
 const schema = `
 create table if not exists sessions (
   id text primary key,
   token text not null unique,
   project_dir text not null,
   project_name text not null,
-  tester text not null,
+  guest text not null,
   brief text not null,
   greeting text not null,
   agent text not null,
@@ -41,76 +42,296 @@ create table if not exists messages (
   role text not null,
   body text not null,
   images text not null default '[]',
-  -- For tester messages: the turn that answered it (null while waiting).
+  -- For guest messages: the turn that answered it (null while waiting).
   -- For agent and error messages: the turn that produced it.
   turn_id integer references turns(id),
+  tries integer not null default 0,
+  client_id text,
   created_at text not null
 );
 create index if not exists messages_session on messages(session_id, id);
 create index if not exists turns_session on turns(session_id, id);
+create unique index if not exists messages_client on messages(session_id, client_id) where client_id is not null;
 `;
+// Changes to a project's database since parley 0.1.2, in order. New
+// databases start with the schema above, which already has them all; a
+// project's .parley folder can outlive any version of parley, so these stay.
+const UPGRADES = [
+    `alter table messages add column tries integer not null default 0;
+   alter table messages add column client_id text;
+   create unique index messages_client on messages(session_id, client_id) where client_id is not null;`,
+    `alter table sessions rename column tester to guest;
+   update messages set role = 'guest' where role = 'tester';`,
+];
 const now = () => new Date().toISOString();
+// A project's own parley folder: its sessions' database, and a folder per
+// session with the screenshots and a readable transcript. Kept out of git,
+// and out of the interviewer's reach (see agents/).
+export const parleyDir = (projectDir) => join(projectDir, ".parley");
+export const sessionDir = (session) => join(parleyDir(session.project_dir), session.id);
+// Every project you've made parleys in. Each keeps its conversations in its
+// own .parley folder; ~/.parley/projects.json only lists where they are.
 export class Store {
-    db;
-    constructor(file = paths.db) {
+    projects = new Map();
+    // Which project each session lives in, as they're looked up.
+    where = new Map();
+    constructor() {
         ensureHome();
-        this.db = new DatabaseSync(file);
-        this.db.exec("pragma journal_mode = wal; pragma busy_timeout = 5000; pragma foreign_keys = on;");
-        this.db.exec(schema);
-        this.addMissingColumns();
-    }
-    // Columns added since a database was first created.
-    addMissingColumns() {
-        const have = new Set(this.db.prepare("pragma table_info(sessions)").all().map((c) => c.name));
-        if (!have.has("read_through"))
-            this.db.exec("alter table sessions add column read_through integer not null default 0");
-        if (!have.has("ended_at"))
-            this.db.exec("alter table sessions add column ended_at text");
-        if (!have.has("reply_limit"))
-            this.db.exec("alter table sessions add column reply_limit integer not null default 100");
-        if (!have.has("e2e_key"))
-            this.db.exec("alter table sessions add column e2e_key text");
-        for (const row of this.db.prepare("select id from sessions where e2e_key is null").all()) {
-            this.db.prepare("update sessions set e2e_key = ? where id = ?").run(newKey(), row.id);
+        this.refresh();
+    }
+    // Opens any project another parley process has added since, and lets go
+    // of any whose .parley folder isn't there anymore (moved or deleted).
+    refresh() {
+        for (const [dir, db] of this.projects) {
+            if (existsSync(join(parleyDir(dir), "parley.db")))
+                continue;
+            db.close();
+            this.projects.delete(dir);
+            for (const [id, owner] of this.where)
+                if (owner === db)
+                    this.where.delete(id);
+        }
+        const listed = readProjects();
+        if (!listed)
+            return;
+        for (const dir of listed) {
+            if (this.projects.has(dir) || !existsSync(join(parleyDir(dir), "parley.db")))
+                continue;
+            const db = new ProjectDb(dir);
+            // A copied project brings copies of its sessions, keys and all. The
+            // first one listed keeps them; the copy is left alone.
+            const taken = db.ids().some((id) => [...this.projects.values()].some((other) => other.session(id)));
+            if (taken) {
+                console.error(`parley: ${dir} holds copies of another project's sessions; leaving it out.`);
+                db.close();
+                continue;
+            }
+            this.projects.set(dir, db);
         }
-        this.db.exec("update sessions set status = 'ended', ended_at = coalesce(ended_at, updated_at) where status not in ('open', 'ended')");
+    }
+    project(dir) {
+        dir = realpathSync(dir);
+        let db = this.projects.get(dir);
+        if (!db) {
+            mkdirSync(parleyDir(dir), { recursive: true });
+            // Everything in here stays out of git without touching your .gitignore.
+            writeFileSync(join(parleyDir(dir), ".gitignore"), "# parley's conversations, kept out of git\n*\n");
+            db = new ProjectDb(dir);
+            this.projects.set(dir, db);
+            const listed = readProjects();
+            if (!listed)
+                throw new Error(`Can't read ${paths.projects}. Fix or delete it, then try again.`);
+            if (!listed.includes(dir))
+                writeProjects([...listed, dir]);
+        }
+        return db;
+    }
+    of(id) {
+        let db = this.where.get(id);
+        if (db)
+            return db;
+        for (const pass of [0, 1]) {
+            if (pass)
+                this.refresh();
+            for (const candidate of this.projects.values()) {
+                if (candidate.session(id)) {
+                    this.where.set(id, candidate);
+                    return candidate;
+                }
+            }
+        }
+        return undefined;
+    }
+    // Whichever project holds a session; for one that doesn't exist, nothing.
+    on(id, fn, fallback) {
+        const db = this.of(id);
+        return db ? fn(db) : fallback;
     }
     createSession(input) {
-        const id = shortId();
+        let id = shortId();
+        while (this.of(id))
+            id = shortId();
+        const db = this.project(input.projectDir);
+        db.createSession(id, input);
+        this.where.set(id, db);
+        this.addMessage(id, "agent", db.session(id).greeting, [], null);
+        return this.session(id);
+    }
+    session(id) {
+        return this.on(id, (db) => db.session(id), undefined);
+    }
+    sessionByToken(token) {
+        for (const pass of [0, 1]) {
+            if (pass)
+                this.refresh();
+            for (const db of this.projects.values()) {
+                const session = db.sessionByToken(token);
+                if (session)
+                    return session;
+            }
+        }
+        return undefined;
+    }
+    sessions(filter = {}) {
+        this.refresh();
+        const dir = filter.projectDir && (existsSync(filter.projectDir) ? realpathSync(filter.projectDir) : resolve(filter.projectDir));
+        const dbs = dir ? [this.projects.get(dir)].filter((db) => !!db) : [...this.projects.values()];
+        return dbs.flatMap((db) => db.sessions(filter.status)).sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    }
+    // Erases the session: transcript, turns, screenshots and its folder.
+    deleteSession(id) {
+        const session = this.session(id);
+        if (!session)
+            return;
+        this.of(id).deleteSession(id);
+        this.where.delete(id);
+        rmSync(sessionDir(session), { recursive: true, force: true });
+    }
+    end(id) {
+        this.on(id, (db) => db.end(id), undefined);
+        this.write(id);
+    }
+    setReplyLimit(id, limit) {
+        this.on(id, (db) => db.setReplyLimit(id, limit), undefined);
+    }
+    repliesUsed(id) {
+        return this.on(id, (db) => db.repliesUsed(id), 0);
+    }
+    latestModel(id) {
+        return this.on(id, (db) => db.latestModel(id), null);
+    }
+    markRead(id, messageId) {
+        this.on(id, (db) => db.markRead(id, messageId), undefined);
+    }
+    setAgentSessionId(id, agentSessionId) {
+        this.on(id, (db) => db.setAgentSessionId(id, agentSessionId), undefined);
+    }
+    addMessage(sessionId, role, body, images, turnId, clientId = null) {
+        const message = this.of(sessionId).addMessage(sessionId, role, body, images, turnId, clientId);
+        this.write(sessionId);
+        return message;
+    }
+    messages(sessionId, afterId = 0) {
+        return this.on(sessionId, (db) => db.messages(sessionId, afterId), []);
+    }
+    page(sessionId, limit, beforeId) {
+        return this.on(sessionId, (db) => db.page(sessionId, limit, beforeId), { messages: [], more: false });
+    }
+    pending(sessionId) {
+        return this.on(sessionId, (db) => db.pending(sessionId), []);
+    }
+    startTurn(session, messageIds) {
+        return this.of(session.id).startTurn(session, messageIds);
+    }
+    turn(sessionId, id) {
+        return this.on(sessionId, (db) => db.turn(id), undefined);
+    }
+    turns(sessionId) {
+        return this.on(sessionId, (db) => db.turns(sessionId), []);
+    }
+    addActivity(sessionId, turnId, line) {
+        this.on(sessionId, (db) => db.addActivity(turnId, line), undefined);
+    }
+    finishTurn(sessionId, turnId, status, usage, error) {
+        this.on(sessionId, (db) => db.finishTurn(turnId, status, usage, error), undefined);
+    }
+    releaseTurn(sessionId, turnId) {
+        this.on(sessionId, (db) => db.releaseTurn(turnId), undefined);
+    }
+    failTurn(sessionId, turnId) {
+        return this.on(sessionId, (db) => db.failTurn(turnId), { retrying: 0, setAside: 0 });
+    }
+    messageByClient(sessionId, clientId) {
+        return this.on(sessionId, (db) => db.messageByClient(sessionId, clientId), undefined);
+    }
+    // Turns that never finished (the server stopped mid-reply), everywhere.
+    recoverInterrupted() {
+        this.refresh();
+        return [...this.projects.values()].flatMap((db) => db.recoverInterrupted());
+    }
+    stats(sessionId) {
+        return this.of(sessionId).stats(sessionId);
+    }
+    // Keeps <session>/transcript.md in step, for you and your agent to read.
+    // Not if the project has moved out from under us: no folders get made at
+    // the old path.
+    write(sessionId) {
+        const session = this.session(sessionId);
+        if (!session || !existsSync(parleyDir(session.project_dir)))
+            return;
+        mkdirSync(sessionDir(session), { recursive: true });
+        writeFileSync(join(sessionDir(session), "transcript.md"), record(this, session));
+    }
+}
+// The listed projects; an empty list if there's no file yet, and null if
+// it can't be read (so nothing overwrites it with a list of one).
+function readProjects() {
+    if (!existsSync(paths.projects))
+        return [];
+    try {
+        const list = JSON.parse(readFileSync(paths.projects, "utf8"));
+        return Array.isArray(list) ? list.filter((dir) => typeof dir === "string") : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Written whole and then swapped in, so a crash can't leave half a file.
+function writeProjects(list) {
+    const temp = `${paths.projects}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(list, null, 2) + "\n");
+    renameSync(temp, paths.projects);
+}
+// One project's sessions, in <project>/.parley/parley.db.
+class ProjectDb {
+    db;
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+        this.db = new DatabaseSync(join(parleyDir(dir), "parley.db"));
+        this.db.exec("pragma journal_mode = wal; pragma busy_timeout = 5000; pragma foreign_keys = on;");
+        const fresh = !this.db.prepare("select 1 from sqlite_master where name = 'sessions'").get();
+        if (fresh)
+            this.db.exec(`begin; ${schema} pragma user_version = ${UPGRADES.length}; commit;`);
+        const at = Number(this.db.prepare("pragma user_version").get().user_version);
+        for (let v = at; v < UPGRADES.length; v++)
+            this.db.exec(`begin; ${UPGRADES[v]} pragma user_version = ${v + 1}; commit;`);
+    }
+    // A project that moved still has its sessions; they're wherever it is now.
+    row = (row) => row && { ...row, project_dir: this.dir };
+    ids() {
+        return this.db.prepare("select id from sessions").all().map((r) => String(r.id));
+    }
+    close() {
+        try {
+            this.db.close();
+        }
+        catch { }
+    }
+    createSession(id, input) {
         const token = randomBytes(18).toString("base64url");
-        const projectName = basename(input.projectDir);
+        const projectName = basename(this.dir);
         const greeting = input.greeting?.trim() ||
-            `Hi ${input.tester}! Thanks for trying ${projectName}. Tell me anything: what you tried, what tripped you up, what you liked. Long rambling brain dumps are perfect.`;
+            `Hi ${input.guest}! Thanks for trying ${projectName}. Tell me anything: what you tried, what tripped you up, what you liked. Long rambling brain dumps are perfect.`;
         const t = now();
         this.db
-            .prepare(`insert into sessions (id, token, project_dir, project_name, tester, brief, greeting, agent, model, reply_limit, e2e_key, status, created_at, updated_at)
+            .prepare(`insert into sessions (id, token, project_dir, project_name, guest, brief, greeting, agent, model, reply_limit, e2e_key, status, created_at, updated_at)
          values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'open', ?, ?)`)
-            .run(id, token, input.projectDir, projectName, input.tester, input.brief, greeting, input.agent, input.model ?? null, input.replyLimit, newKey(), t, t);
-        this.addMessage(id, "agent", greeting, [], null);
-        return this.session(id);
+            .run(id, token, this.dir, projectName, input.guest, input.brief, greeting, input.agent, input.model ?? null, input.replyLimit, newKey(), t, t);
     }
     session(id) {
-        return this.db.prepare("select * from sessions where id = ?").get(id);
+        return this.row(this.db.prepare("select * from sessions where id = ?").get(id));
     }
     sessionByToken(token) {
-        return this.db.prepare("select * from sessions where token = ?").get(token);
+        return this.row(this.db.prepare("select * from sessions where token = ?").get(token));
     }
-    sessions(filter = {}) {
-        return this.db
-            .prepare(`select * from sessions
-         where (?1 is null or project_dir = ?1) and (?2 is null or status = ?2)
-         order by updated_at desc`)
-            .all(filter.projectDir ?? null, filter.status ?? null);
+    sessions(status) {
+        return this.db.prepare("select * from sessions where (?1 is null or status = ?1)").all(status ?? null).map((r) => this.row(r));
     }
-    // Erases the session: transcript, turns, and screenshots.
     deleteSession(id) {
         this.db.prepare("delete from messages where session_id = ?").run(id);
         this.db.prepare("delete from turns where session_id = ?").run(id);
         this.db.prepare("delete from sessions where id = ?").run(id);
-        for (const name of readdirSync(paths.uploads)) {
-            if (name.startsWith(`${id}-`))
-                rmSync(join(paths.uploads, name), { force: true });
-        }
     }
     end(id) {
         const t = now();
@@ -140,10 +361,10 @@ export class Store {
     touch(id) {
         this.db.prepare("update sessions set updated_at = ? where id = ?").run(now(), id);
     }
-    addMessage(sessionId, role, body, images, turnId) {
+    addMessage(sessionId, role, body, images, turnId, clientId = null) {
         const result = this.db
-            .prepare("insert into messages (session_id, role, body, images, turn_id, created_at) values (?, ?, ?, ?, ?, ?)")
-            .run(sessionId, role, body, JSON.stringify(images), turnId, now());
+            .prepare("insert into messages (session_id, role, body, images, turn_id, client_id, created_at) values (?, ?, ?, ?, ?, ?, ?)")
+            .run(sessionId, role, body, JSON.stringify(images), turnId, clientId, now());
         this.touch(sessionId);
         return this.message(Number(result.lastInsertRowid));
     }
@@ -164,7 +385,7 @@ export class Store {
     }
     pending(sessionId) {
         return this.db
-            .prepare("select * from messages where session_id = ? and role = 'tester' and turn_id is null order by id")
+            .prepare("select * from messages where session_id = ? and role = 'guest' and turn_id is null order by id")
             .all(sessionId).map(parseMessage);
     }
     startTurn(session, messageIds) {
@@ -196,7 +417,20 @@ export class Store {
             .run(status, usage ? JSON.stringify(usage) : null, error, now(), turnId);
     }
     releaseTurn(turnId) {
-        this.db.prepare("update messages set turn_id = null where turn_id = ? and role = 'tester'").run(turnId);
+        this.db.prepare("update messages set turn_id = null where turn_id = ? and role = 'guest'").run(turnId);
+    }
+    // A reply failed: its messages go back in the queue to ride along with the
+    // next one, unless they've already failed once, in which case they're set
+    // aside (still saved, never retried) so one bad message can't sink the rest.
+    failTurn(turnId) {
+        this.db.prepare("update messages set tries = tries + 1 where turn_id = ? and role = 'guest'").run(turnId);
+        const back = this.db.prepare("update messages set turn_id = null where turn_id = ? and role = 'guest' and tries < 2").run(turnId);
+        const aside = this.db.prepare("select count(*) as n from messages where turn_id = ? and role = 'guest'").get(turnId);
+        return { retrying: Number(back.changes), setAside: Number(aside.n) };
+    }
+    messageByClient(sessionId, clientId) {
+        const row = this.db.prepare("select * from messages where session_id = ? and client_id = ?").get(sessionId, clientId);
+        return row && parseMessage(row);
     }
     // A turn that never finished (server stopped mid-reply) gives its messages
     // back to the queue so they are answered when the server comes back.
@@ -213,11 +447,11 @@ export class Store {
     stats(sessionId) {
         const row = this.db
             .prepare(`select
-           coalesce(sum(m.role = 'tester'), 0) as tester_messages,
+           coalesce(sum(m.role = 'guest'), 0) as guest_messages,
            coalesce(sum(m.role = 'agent'), 0) as agent_messages,
-           coalesce(sum(m.role = 'tester' and m.id > s.read_through), 0) as unread,
+           coalesce(sum(m.role = 'guest' and m.id > s.read_through), 0) as unread,
            max(m.created_at) as last_message_at,
-           max(case when m.role = 'tester' then m.created_at end) as last_tester_at
+           max(case when m.role = 'guest' then m.created_at end) as last_guest_at
          from sessions s left join messages m on m.session_id = s.id
          where s.id = ?`)
             .get(sessionId);

package/dist/mcp.js

@@ -8,9 +8,9 @@ import { linkFor, dashboardUrl, isServerUp } from "./state.js";
 import { transcript, summaryLine } from "./transcript.js";
 import { startSession, endSession, setReplyLimit } from "./control.js";
 import { readCredentials } from "./account.js";
-const INSTRUCTIONS = `Parley lets the user hand a tester a link to a private web chat with a read-only Claude or Codex running in their project folder. The tester talks; the agent listens, asks follow-ups, answers questions from the code, and everything is recorded.
+const INSTRUCTIONS = `Parley lets the user hand a guest a link to a private web chat with a read-only Claude or Codex running in their project folder. The guest talks; the agent listens, asks follow-ups, answers questions from the code, and everything is recorded.
 
-Use create_session when the user wants someone to give feedback on a project. Write the brief from what you know about the project and what the user wants to learn. Later, use list_sessions to see which sessions are open, which have new messages, and how many replies each has used and spent; get_transcript to read them; set_reply_limit to give a session more room or less; and end_session when the user is done with one. Links live on parley.im and are end-to-end encrypted; the conversation itself happens on the user's computer, so testers can only get replies while it's awake and the parley server is running.`;
+Use create_session when the user wants someone to give feedback on a project. Write the brief from what you know about the project and what the user wants to learn. Later, use list_sessions to see which sessions are open, which have new messages, and how many replies each has used and spent; get_transcript to read them; set_reply_limit to give a session more room or less; and end_session when the user is done with one. Links live on parley.im and are end-to-end encrypted; the conversation itself happens on the user's computer, so guests can only get replies while it's awake and the parley server is running.`;
 export async function runMcp() {
     const config = loadConfig();
     const store = new Store();
@@ -20,25 +20,25 @@ export async function runMcp() {
     const currentLink = (id) => linkFor(store.session(id), config);
     server.registerTool("create_session", {
         title: "Create a feedback session",
-        description: "Create a parley session: a private link the user can send to a tester. The tester chats with a fresh, read-only " +
+        description: "Create a parley session: a private link the user can send to a guest. The guest chats with a fresh, read-only " +
             "agent in the project folder that hears their feedback, answers questions by reading the code, and records everything. " +
             "Starts the local server and tunnel if needed. Returns the link to give the user.",
         inputSchema: {
             project_dir: z.string().describe("Absolute path of the project folder, normally your current working directory."),
-            tester: z.string().describe("Name of the person who will give feedback, e.g. 'Sam'."),
+            guest: z.string().describe("Name of the person who will give feedback, e.g. 'Sam'."),
             brief: z
                 .string()
                 .describe("Instructions for the interviewer, written to it directly. Cover what the project is and its current state, " +
-                "how the tester will try it (URL, build, steps), what the user most wants to learn, known issues not worth " +
-                "digging into, and anything about the tester that helps. A few short paragraphs."),
+                "how the guest will try it (URL, build, steps), what the user most wants to learn, known issues not worth " +
+                "digging into, and anything about the guest that helps. A few short paragraphs."),
             greeting: z
                 .string()
                 .optional()
-                .describe("The first message the tester sees, from the interviewer. Short and warm. A default is used if omitted."),
+                .describe("The first message the guest sees, from the interviewer. Short and warm. A default is used if omitted."),
             agent: z
                 .enum(["claude", "codex"])
                 .optional()
-                .describe("Which agent interviews the tester. Defaults to whichever agent is calling this tool."),
+                .describe("Which agent interviews the guest. Defaults to whichever agent is calling this tool."),
             model: z.string().optional().describe("Model override for the interviewer. Usually leave unset."),
             reply_limit: z
                 .number()
@@ -52,7 +52,7 @@ export async function runMcp() {
         try {
             made = await startSession(store, config, {
                 projectDir: args.project_dir,
-                tester: args.tester,
+                guest: args.guest,
                 brief: args.brief,
                 greeting: args.greeting,
                 agent: args.agent ?? callerAgent(),
@@ -65,9 +65,9 @@ export async function runMcp() {
         }
         const { session } = made;
         const lines = [
-            `Created session ${session.id} for ${session.tester} (${session.agent}, read-only in ${session.project_dir}, up to ${session.reply_limit} replies).`,
+            `Created session ${session.id} for ${session.guest} (${session.agent}, read-only in ${session.project_dir}, up to ${session.reply_limit} replies).`,
             "",
-            `Link for ${session.tester}: ${linkFor(session, config)}`,
+            `Link for ${session.guest}: ${linkFor(session, config)}`,
             `Watch it live on the control panel: ${dashboardUrl(config, session)}`,
             "",
         ];
@@ -81,15 +81,15 @@ export async function runMcp() {
             lines.push("Warning: parley.im didn't take the session yet. It will once the connection is back; `parley status` shows it.");
         }
         else {
-            lines.push("Everything after the # in the link is the session's encryption key: share the whole link, and only with the tester. " +
+            lines.push("Everything after the # in the link is the session's encryption key: share the whole link, and only with the guest. " +
                 "Replies come from this computer, so it needs to be awake with parley running.");
         }
         return reply(lines.join("\n"));
     });
     server.registerTool("list_sessions", {
         title: "List feedback sessions",
-        description: "List parley sessions, newest activity first, with how many tester messages are new since you last read each one. " +
-            "Open sessions include their current tester link.",
+        description: "List parley sessions, newest activity first, with how many guest messages are new since you last read each one. " +
+            "Open sessions include their current guest link.",
         inputSchema: {
             status: z.enum(["open", "ended", "all"]).optional().describe("Defaults to open."),
             project_dir: z.string().optional().describe("Only sessions for this project folder. Omit for every project."),
@@ -103,14 +103,14 @@ export async function runMcp() {
         if (!sessions.length)
             return reply(status === "all" ? "No sessions yet." : `No ${status} sessions.`);
         const down = status !== "ended" && !(await isServerUp(config))
-            ? "The parley server is not running, so testers can't get replies. Run `parley start` to bring it back.\n\n"
+            ? "The parley server is not running, so guests can't get replies. Run `parley start` to bring it back.\n\n"
             : "";
         return reply(down + sessions.map((s) => summaryLine(store, s, linkFor(s, config))).join("\n\n"));
     });
     server.registerTool("get_transcript", {
         title: "Read a feedback session",
         description: "Read a parley session as Markdown: the brief, every message, which model interviewed, and paths to screenshots the " +
-            "tester shared. Set only_new to read just what came in since you last read it. Reading marks it read.",
+            "guest shared. Set only_new to read just what came in since you last read it. Reading marks it read.",
         inputSchema: {
             session_id: z.string(),
             only_new: z.boolean().optional(),
@@ -123,7 +123,7 @@ export async function runMcp() {
     });
     server.registerTool("end_session", {
         title: "End a feedback session",
-        description: "End a parley session for good when the user is done with it. The tester's link stops working entirely and an open " +
+        description: "End a parley session for good when the user is done with it. The guest's link stops working entirely and an open " +
             "page clears itself. The transcript stays readable here. This can't be undone; make a new session to talk again.",
         inputSchema: { session_id: z.string() },
     }, async (args) => {
@@ -133,12 +133,12 @@ export async function runMcp() {
         if (session.status !== "open")
             return reply(`Session ${session.id} had already ended.`);
         await endSession(config, store, session.id);
-        return reply(`Ended ${session.id} (${session.tester} on ${session.project_name}). The link no longer works; the transcript is kept. ` +
+        return reply(`Ended ${session.id} (${session.guest} on ${session.project_name}). The link no longer works; the transcript is kept. ` +
             `To erase it completely, the user can run \`parley delete ${session.id}\`.`);
     });
     server.registerTool("set_reply_limit", {
         title: "Change a session's reply limit",
-        description: "Set how many replies the interviewer may give in a session in total. When a session runs out it pauses: the tester " +
+        description: "Set how many replies the interviewer may give in a session in total. When a session runs out it pauses: the guest " +
             "can't send more until the limit is raised. Use it when the user wants to give a session more room, or rein it in.",
         inputSchema: { session_id: z.string(), limit: z.number().int().positive().describe("Total replies allowed, including ones already given.") },
     }, async (args) => {
@@ -147,7 +147,7 @@ export async function runMcp() {
             return { ...reply(`No session ${args.session_id}.`), isError: true };
         await setReplyLimit(config, store, session.id, args.limit);
         const used = store.repliesUsed(session.id);
-        return reply(`${session.id} (${session.tester}) may now give ${args.limit} replies in total; ${used} used so far.`);
+        return reply(`${session.id} (${session.guest}) may now give ${args.limit} replies in total; ${used} used so far.`);
     });
     await server.connect(new StdioServerTransport());
 }

package/dist/models.js

@@ -1,10 +1,16 @@
-// "claude-opus-5-5" reads better as "Opus 5.5". Anything else (Codex models,
-// aliases) is shown as it is.
+// Models by the names their makers use: "claude-opus-5-5" is "Opus 5.5" and
+// "gpt-6-astra" is "GPT-6 Astra". Anything else (aliases, o-series) is shown
+// as it is.
 export function modelLabel(model) {
     if (!model)
         return null;
     const claude = model.match(/^claude-([a-z]+)-(\d+)-(\d+)(?:-\d{8})?$/);
     if (claude)
         return `${claude[1][0].toUpperCase()}${claude[1].slice(1)} ${claude[2]}.${claude[3]}`;
+    const gpt = model.match(/^gpt-([\d.]+)((?:-[a-z0-9]+)*)$/);
+    if (gpt) {
+        const words = gpt[2].split("-").filter(Boolean).map((w) => (/^(mini|nano)$/.test(w) ? w : w[0].toUpperCase() + w.slice(1)));
+        return [`GPT-${gpt[1]}`, ...words].join(" ");
+    }
     return model;
 }