@parley-im/parley 0.1.2 → 0.2.1

package/README.md

@@ -2,7 +2,7 @@
 
 Send someone a link. They open a private chat with your own Claude or Codex, running read-only in your project folder, and tell it what they think. It asks follow-up questions, answers their questions by reading the code, and saves everything for you.
 
-The agent runs on your computer, with your Claude or Codex login and plan. Links live on **parley.im**, which passes the conversation between the tester's browser and your computer **end-to-end encrypted**: it can't read what's said.
+The agent runs on your computer, with your Claude or Codex login and plan. Links live on **parley.im**, which passes the conversation between the guest's browser and your computer **end-to-end encrypted**: it can't read what's said.
 
 ## Using it
 
@@ -18,14 +18,14 @@ Then, from any Claude Code or Codex session:
 
 Your agent writes a brief from what it knows and hands back a link like `https://parley.im/s/…#…`. Send Sam the whole link: the part after `#` is the conversation's key. Later:
 
-> Anything new from testers? Summarize it and file the bugs.
+> Anything new from guests? Summarize it and file the bugs.
 
 > We're done with Sam's session.
 
 Or from a terminal:
 
 ```bash
-parley new --tester Sam --brief "Sam is trying the new onboarding on their phone. Find out where they got stuck."
+parley new --guest Sam --brief "Sam is trying the new onboarding on their phone. Find out where they got stuck."
 parley list              # open sessions: new messages, replies used, spend (--ended, --all)
 parley show <id> --new   # what came in since you last read it
 parley limit <id> 150    # let a session give 150 replies in total
@@ -38,24 +38,24 @@ parley whoami | logout
 ## How it fits together
 
 ```
-tester's browser ──wss──▶ parley.im (Cloudflare Worker) ◀──wss── your computer (parley server)
+guest's browser ──wss──▶ parley.im (Cloudflare Worker) ◀──wss── your computer (parley server)
    key from #            sender accounts, open sessions,            agent runs here, transcripts
    seals everything      relays ciphertext, stores none of it       and screenshots stay here,
                                                                     holds each session's key
 ```
 
-- **Accounts are for senders only**, signed in with Google and keyed on the verified email, so a later sign-in method with the same email joins the same account. Testers never sign in: the link is their access.
+- **Accounts are for senders only**, signed in with Google and keyed on the verified email, so a later sign-in method with the same email joins the same account. Guests never sign in: the link is their access.
 - **`parley login`** works like `gh auth login`: your computer shows a code, you approve it at parley.im while signed in, and the computer gets its own token. Unlink computers from your account page on parley.im.
 - **Your computer connects out** to parley.im over a WebSocket; nothing listens for the internet on your machine. The server starts on demand (or `parley start`) and holds that connection.
-- **parley.im stores** accounts, linked computers, and each open session's id and title (the project name, for link previews). It forgets a session the moment it ends. Messages and screenshots only pass through, encrypted, between the tester's browser and your computer; screenshots cross in pieces over the same connection, and your computer serves them back to the page.
+- **parley.im stores** accounts, linked computers, and each open session's id and title (the project name, for link previews). It forgets a session the moment it ends. Messages and screenshots only pass through, encrypted, between the guest's browser and your computer; screenshots cross in pieces over the same connection, and your computer serves them back to the page.
 
 ### End-to-end encryption
 
 Each session has a random 256-bit key, kept in your parley database and in the link after the `#`, which browsers never send to a server. Every request, reply, live update and screenshot is sealed with AES-256-GCM (fresh IV each time) and bound to its session and direction, so parley.im can't read or alter anything, or move it between sessions. Your computer refuses requests older than five minutes or seen before, so replays go nowhere. `src/seal.ts` and `web/seal.js` are the two halves; the tests check they read each other.
 
-What it doesn't hide, said plainly on the tester's info sheet: parley.im knows who sent a link, the project name, and when messages pass; the page's code comes from parley.im, so the promise relies on parley.im serving it honestly (a strict Content-Security-Policy means the key can only ever go back to parley.im); and Claude or Codex reads the conversation to reply. Anyone with the whole link can read and join the chat.
+What it doesn't hide, said plainly on the guest's info sheet: parley.im knows who sent a link, the project name, and when messages pass; the page's code comes from parley.im, so the promise relies on parley.im serving it honestly (a strict Content-Security-Policy means the key can only ever go back to parley.im); and Claude or Codex reads the conversation to reply. Anyone with the whole link can read and join the chat.
 
-## What the tester gets
+## What the guest gets
 
 A chat page built for phones first, in a plain technical style (a transcript, not chat bubbles). The header shows who's answering (the model, once the first reply names it) and how many replies are left; the ⓘ sheet explains who sent it (verified by parley.im), what the agent can and can't do, that everything is saved and encrypted, and when the link stops working. Replies stream in as plain conversation; the agent's lookups only show in your view. Markdown renders, tables and quotes included; HTML stays text. Screenshots can be pasted, dropped or picked. If they're at the bottom, the view stays there through streaming, images, resizing and the keyboard (on iOS the page pins itself above the keyboard); long conversations load older messages as you scroll up. If your computer is asleep, the page still loads and says so.
 
@@ -63,10 +63,12 @@ A chat page built for phones first, in a plain technical style (a transcript, no
 
 Each session is a fresh agent conversation in the project folder, guided by a charter (`src/charter.ts`), your brief, and the project's CLAUDE.md and AGENTS.md. It talks about the product as a user sees it and only gets into files and internals when asked.
 
-It can read the project folder and nothing else on your computer, and not the project's `.parley` folder, where other people's conversations are. That's enforced by each agent's own sandbox, not just asked of it (the charter asks too):
+It can read the project folder and nothing else on your computer. Inside it, a blocked list keeps it from secrets (`.env` files, keys and certificates, `.ssh`, cloud and package-manager logins, `secrets/`), from other guests' conversations in any `.parley` folder, and always from parley's own database. Each agent's own sandbox enforces that, not just the charter (which asks too). `src/access.ts` builds the rules; sessions won't start in your home folder. Both are settings (see Config).
 
-- **Claude:** `claude -p --restricted --tools Read,Grep,Glob --strict-mcp-config`, plus a `Read(./.parley/**)` deny rule. No command, write or web tools; `--restricted` confines the file tools to the project; your MCP servers are left out.
-- **Codex:** `codex exec --ignore-user-config` under a permission profile that can read the project and the system files tools need (`:minimal`), with `.parley` denied, no writes and no network. Apps, browser, computer use, plugins, hooks and web search are off; your model and reasoning effort carry over. Codex re-runs itself inside that sandbox, so parley starts it by its real path and lets it read that one file.
+- **Claude:** `claude -p --restricted --tools Read,Grep,Glob --strict-mcp-config`, plus `Read(...)` deny rules from the blocked list. No command, write or web tools; `--restricted` confines the file tools to the project; your MCP servers are left out.
+- **Codex:** `codex exec --ignore-user-config` under a permission profile that can read the project and the system files tools need (`:minimal`), with the blocked list denied, no writes and no network. Apps, browser, computer use, plugins, hooks and web search are off; your model and reasoning effort carry over. Codex re-runs itself inside that sandbox, so parley starts it by its real path and lets it read that one file.
+
+Before a session is made, parley checks the agent is installed and new enough for these flags, and says what to update if not.
 
 Each reply records which model answered, on which login (`auth: "none"` means your subscription, not an API key), and what it would cost at API prices.
 
@@ -77,7 +79,7 @@ Each reply records which model answered, on which login (`auth: "none"` means yo
 ## Keeping it in hand
 
 - **Reply limit:** 100 per session by default (`replyLimit`, or per session); then it pauses until you add more.
-- **Anti-spam:** per session, a burst of 20 messages, then one every 3 seconds; parley.im also rate-limits each tester connection.
+- **Anti-spam:** per session, a burst of 20 messages, then one every 3 seconds; parley.im also rate-limits each guest connection.
 - **Message size:** up to 20,000 characters, refused with the count if longer.
 - **End** kills the link at once and parley.im forgets the session; **delete** also erases the transcript and screenshots on your computer.
 
@@ -93,16 +95,16 @@ Each reply records which model answered, on which login (`auth: "none"` means yo
 | `src/runner.ts`, `src/agents/` | One reply at a time per session; Claude and Codex adapters |
 | `src/mcp.ts` | `create_session`, `list_sessions`, `get_transcript`, `set_reply_limit`, `end_session` |
 | `src/db.ts` | Each project's `.parley/parley.db` (sessions with keys, messages, turns), a folder per session with screenshots and `transcript.md`, and `~/.parley/projects.json` listing the projects |
-| `web/` | Chat page, session view, control panel; parley.im serves the tester page's files from here too |
+| `web/` | Chat page, session view, control panel; parley.im serves the guest page's files from here too |
 | `relay/` | parley.im: Worker, a Durable Object per linked computer, D1; the front page's animation is `web/home.js` |
 
 ## Setup
 
-Requires Node 24+ on macOS or Linux, and Claude Code and/or Codex logged in.
+Requires Node 22.13+ on macOS or Linux, and Claude Code and/or Codex logged in.
 
 ```bash
 npm install -g @parley-im/parley
-parley install   # registers the MCP server with Claude Code and Codex
+parley install   # registers the MCP server with Claude Code and Codex, and starts parley at login
 parley login
 ```
 
@@ -116,11 +118,11 @@ The npm package is `@parley-im/parley` (the parley-im org; plain `parley` is tak
 
 Conversations live with their project, in `<project>/.parley/`: a database, and a folder per session holding its screenshots and a `transcript.md` your agent can read. The folder carries its own `.gitignore`, so it stays out of git. `~/.parley` keeps only settings, your parley.im login, the server's state and log, and the list of projects.
 
-`~/.parley/config.json`: `relayUrl` (default `https://parley.im`), `ownerName` (defaults to your account's first name), `replyLimit`, ports, and `claude`/`codex` model and effort overrides. Without `parley login`, links are local-only (`http://localhost:4747/...`), for development.
+`~/.parley/config.json`: `relayUrl` (default `https://parley.im`), `ownerName` (defaults to your account's first name), `replyLimit`, ports, `claude`/`codex` model and effort overrides, and `interviewer`: `readConversations` (default false), `blocked` (globs from the project folder, starting with the defaults in `src/config.ts`) and `allowHomeFolder` (default false). Without `parley login`, links are local-only (`http://localhost:4747/...`), for development.
 
 ## Running parley.im
 
-`relay/` is a Cloudflare Worker (`wrangler.jsonc`) with a Durable Object per linked computer and a D1 database (`migrations/`). Signed out, `/` is a wordless animation; signed in, it's your dashboard (open sessions, linked computers and whether they're online). `/docs` is the install guide. Secrets: `SESSION_SECRET` (random), `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` (a Google OAuth web client with redirect URI `https://parley.im/auth/google/callback`).
+`relay/` is a Cloudflare Worker (`wrangler.jsonc`) with a Durable Object per linked computer and a D1 database (`migrations/`). Signed out, `/` is a wordless animation; signed in, it's your dashboard (open sessions, linked computers and whether they're online). `/docs` is the install guide; `/admin` is for admins (`ADMIN_EMAILS`): invites, the waitlist and who's in. Email goes through Cloudflare Email Service (the `EMAIL` binding, from `hello@parley.im`): a note when someone joins the waitlist (to them and the admins), when they're let in, and invites. Rate limits use the `LIMITS` binding. Secrets: `SESSION_SECRET` (random), `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` (a Google OAuth web client with redirect URI `https://parley.im/auth/google/callback`).
 
 ```bash
 cd relay

package/bin/parley

@@ -3,6 +3,13 @@
 // npm package ships only the compiled dist/.
 import { existsSync } from "node:fs";
 
+// node:sqlite arrived in Node 22.13; anything older can't run parley at all.
+const [major, minor] = process.versions.node.split(".").map(Number);
+if (major < 22 || (major === 22 && minor < 13)) {
+  console.error(`parley needs Node 22.13 or later, and this is Node ${process.versions.node}. Update Node (https://nodejs.org), then try again.`);
+  process.exit(1);
+}
+
 // node:sqlite still announces itself as experimental; keep that out of
 // parley's output.
 const emit = process.emitWarning;

package/dist/access.js

@@ -0,0 +1,57 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, sep } from "node:path";
+import { cleanEnv, paths } from "./config.js";
+// What the interviewer may not read, as globs from the project folder: your
+// blocked list, other sessions' conversations unless you allow them, and
+// parley's own database (it holds every session's key) always.
+export function blockedPaths(config) {
+    const blocked = [...config.interviewer.blocked, "**/.parley/parley.db*"];
+    if (!config.interviewer.readConversations)
+        blocked.push("**/.parley/**");
+    return [...new Set(blocked)];
+}
+// A session in your home folder (or /) would put everything in it within
+// reach, so that takes an explicit setting.
+export function checkProjectFolder(dir, config) {
+    if (config.interviewer.allowHomeFolder)
+        return;
+    const real = realpathSync(dir);
+    const home = realpathSync(homedir());
+    if (real === sep || real === home || home.startsWith(real + sep)) {
+        throw new Error(`${real} is your home folder or contains it, so the interviewer could read everything in it. Run parley from a project folder instead, or allow it with "allowHomeFolder": true under "interviewer" in ${paths.config}.`);
+    }
+}
+const NAMES = { claude: "Claude Code", codex: "Codex" };
+const UPDATE = { claude: "claude update", codex: "brew upgrade codex, or npm install -g @openai/codex" };
+// The flags parley's sandboxing depends on, as each CLI's help lists them.
+const NEEDS = {
+    claude: { args: ["--help"], flags: ["--restricted", "--permission-prompts", "--settings"] },
+    codex: { args: ["sandbox", "--help"], flags: ["--permission-profile"] },
+};
+const checked = new Map();
+// Why this computer's Claude Code or Codex can't run an interviewer, or null
+// if it can: it has to be installed and new enough for the sandbox.
+export function agentProblem(config, agent) {
+    const bin = config[agent].bin;
+    if (!bin.startsWith("/") || !existsSync(bin))
+        return `${NAMES[agent]} isn't installed on this computer (no ${basename(bin)} found).`;
+    const key = `${bin}@${statSync(bin).mtimeMs}`;
+    if (checked.has(key))
+        return checked.get(key);
+    let problem = null;
+    try {
+        const help = execFileSync(bin, NEEDS[agent].args, { encoding: "utf8", timeout: 20_000, env: cleanEnv(), stdio: ["ignore", "pipe", "pipe"] });
+        if (NEEDS[agent].flags.some((flag) => !help.includes(flag))) {
+            problem = `This ${NAMES[agent]} is too old for parley's sandbox. Update it (${UPDATE[agent]}) and try again.`;
+        }
+    }
+    catch (error) {
+        problem = `${NAMES[agent]} didn't run (${bin}): ${String(error.message).split("\n")[0]}`;
+    }
+    checked.set(key, problem);
+    return problem;
+}
+// Claude Code if it can run an interviewer, otherwise Codex.
+export const defaultAgent = (config) => (agentProblem(config, "claude") && !agentProblem(config, "codex") ? "codex" : "claude");

package/dist/account.js

@@ -20,7 +20,7 @@ export function writeCredentials(creds) {
 export function clearCredentials() {
     rmSync(paths.credentials, { force: true });
 }
-// How the interviewer and tester pages refer to you.
+// How the interviewer and guest pages refer to you.
 export function ownerName(config) {
     const creds = readCredentials(config);
     return config.ownerName ?? creds?.account.givenName ?? creds?.account.name ?? null;
@@ -72,6 +72,10 @@ export async function login(config, show) {
             writeCredentials(creds);
             return creds;
         }
+        // Signed in on parley.im, but not let in yet: no computer links until then.
+        if (poll.status === "waitlisted") {
+            throw new Error(`You're on the parley waitlist as ${poll.email}. You'll get an email when you're let in; then run parley login again.`);
+        }
         if (poll.status === "expired")
             break;
     }

package/dist/agents/claude.js

@@ -2,13 +2,15 @@ import { readFileSync, realpathSync } from "node:fs";
 import { sep } from "node:path";
 import { randomUUID } from "node:crypto";
 import { runJsonLines } from "./process.js";
+import { blockedPaths } from "../access.js";
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
 // Claude Code in print mode, one process per turn, resumed by session id.
 // --restricted drops every tool that runs code, ignores your settings files
 // and confines the file tools to the project folder; --tools narrows it to
-// reading, a deny rule keeps it out of the project's .parley folder (other
-// people's conversations), and --strict-mcp-config keeps your MCP servers
-// (mail, calendar, ...) out of reach. The project's CLAUDE.md and AGENTS.md
-// reach it through the charter.
+// reading; deny rules keep it from your blocked files (secrets, keys, other
+// people's conversations; see access.ts); and --strict-mcp-config keeps your
+// MCP servers (mail, calendar, ...) out of reach. The project's CLAUDE.md and
+// AGENTS.md reach it through the charter.
 export function runClaudeTurn(input, events) {
     const { session, config } = input;
     const agentSessionId = session.agent_session_id ?? randomUUID();
@@ -23,9 +25,9 @@ export function runClaudeTurn(input, events) {
         "--strict-mcp-config",
         "--permission-prompts", "none",
         "--disable-slash-commands",
-        "--settings", JSON.stringify({ permissions: { deny: ["Read(./.parley/**)", `Read(/${session.project_dir}/.parley/**)`] } }),
+        "--settings", JSON.stringify({ permissions: { deny: blockedPaths(config).map((glob) => `Read(./${glob})`) } }),
         "--append-system-prompt", input.charter,
-        "--name", `parley: ${session.tester}`,
+        "--name", `parley: ${session.guest}`,
     ];
     const model = session.model ?? config.claude.model;
     if (model)
@@ -36,14 +38,21 @@ export function runClaudeTurn(input, events) {
         args.push("--resume", agentSessionId);
     else
         args.push("--session-id", agentSessionId);
+    // Claude takes images up to 5 MB; the page shrinks screenshots before
+    // sending, so a bigger one is rare, and is described instead of failing
+    // the reply.
     const content = [];
+    let skipped = 0;
     for (const image of input.images) {
-        content.push({
-            type: "image",
-            source: { type: "base64", media_type: image.mediaType, data: readFileSync(image.path).toString("base64") },
-        });
+        const data = readFileSync(image.path);
+        if (data.length > MAX_IMAGE_BYTES) {
+            skipped++;
+            continue;
+        }
+        content.push({ type: "image", source: { type: "base64", media_type: image.mediaType, data: data.toString("base64") } });
     }
-    content.push({ type: "text", text: input.text });
+    const note = skipped ? `\n\n(${skipped === 1 ? "A screenshot" : `${skipped} screenshots`} came with this but ${skipped === 1 ? "was" : "were"} too large for you to see. Say so if it matters.)` : "";
+    content.push({ type: "text", text: input.text + note });
     const stdin = JSON.stringify({ type: "user", message: { role: "user", content } }) + "\n";
     const texts = [];
     let streamedAny = false;

package/dist/agents/codex.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { runJsonLines } from "./process.js";
+import { blockedPaths } from "../access.js";
 // Features that reach beyond reading the project. Off for every turn.
 const DISABLED_FEATURES = [
     "apps",
@@ -20,10 +21,14 @@ const DISABLED_FEATURES = [
 // model and reasoning effort are carried over. Its commands run under a
 // permission profile that can read the project and the system files tools
 // need, and nothing else: not the rest of your home folder, not other
-// projects, and not the project's .parley folder, where other people's
-// conversations are. No writes, no network. Codex re-runs itself inside that
-// sandbox, so it's started by its real path and may read that one file.
-const profile = (bin) => `permissions.parley={filesystem={":minimal"="read", ${JSON.stringify(bin)}="read", ":workspace_roots"={"."="read", ".parley"="deny"}}}`;
+// projects, and none of your blocked files (secrets, keys, other people's
+// conversations; see access.ts). No writes, no network. Codex re-runs itself
+// inside that sandbox, so it's started by its real path and may read that
+// one file.
+const profile = (bin, blocked) => {
+    const project = [`"."="read"`, ...blocked.map((glob) => `${JSON.stringify(glob)}="deny"`)].join(", ");
+    return `permissions.parley={filesystem={":minimal"="read", ${JSON.stringify(bin)}="read", ":workspace_roots"={${project}}}}`;
+};
 export function runCodexTurn(input, events) {
     const { session, config } = input;
     const defaults = readCodexDefaults();
@@ -37,7 +42,7 @@ export function runCodexTurn(input, events) {
         "--skip-git-repo-check",
         "--cd", session.project_dir,
         "-c", `default_permissions="parley"`,
-        "-c", profile(bin),
+        "-c", profile(bin, blockedPaths(config)),
         "-c", `approval_policy="never"`,
         "-c", `web_search="disabled"`,
         "-c", `developer_instructions=${JSON.stringify(input.charter)}`,

package/dist/agents/process.js

@@ -1,6 +1,8 @@
 import { spawn } from "node:child_process";
 import { cleanEnv } from "../config.js";
 const TURN_LIMIT_MS = 15 * 60 * 1000;
+// How long a stopped agent gets to exit before it's killed outright.
+const GRACE_MS = 5000;
 // Runs one agent turn as a child process that prints JSON lines.
 export function runJsonLines(opts) {
     const child = spawn(opts.bin, opts.args, {
@@ -10,7 +12,19 @@ export function runJsonLines(opts) {
     });
     let stderr = "";
     let buffer = "";
-    const timer = setTimeout(() => child.kill("SIGTERM"), TURN_LIMIT_MS);
+    // Stop politely, then for good: an agent that ignores SIGTERM, or leaves a
+    // process holding its output open, must not block the session's queue.
+    let killer = null;
+    const stop = () => {
+        if (killer)
+            return;
+        child.kill("SIGTERM");
+        killer = setTimeout(() => {
+            child.kill("SIGKILL");
+            finish(null);
+        }, GRACE_MS);
+    };
+    const timer = setTimeout(stop, TURN_LIMIT_MS);
     child.stdout.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
         buffer += chunk;
@@ -36,12 +50,29 @@ export function runJsonLines(opts) {
     });
     child.stdin.on("error", () => { });
     child.stdin.end(opts.stdin);
+    // Done when its output closes; or, if something it started keeps the output
+    // open, shortly after it exits.
+    let finish = () => { };
     const exited = new Promise((resolve, reject) => {
-        child.on("error", reject);
-        child.on("close", (code) => {
+        let settled = false;
+        finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
             clearTimeout(timer);
+            if (killer)
+                clearTimeout(killer);
             resolve({ code, stderr });
+        };
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
         });
+        child.on("close", (code) => finish(code));
+        child.on("exit", (code) => setTimeout(() => finish(code), GRACE_MS));
     });
-    return { exited, cancel: () => child.kill("SIGTERM") };
+    return { exited, cancel: stop };
 }

package/dist/api.js

@@ -11,7 +11,7 @@ const PAGE = 60;
 // 3 seconds. A person typing never notices; a script hammering the link does.
 const BURST = 20;
 const REFILL_MS = 3_000;
-// A refusal the tester's page shows as it is.
+// A refusal the guest's page shows as it is.
 export class Problem extends Error {
     status;
     code;
@@ -53,7 +53,7 @@ export class Conversations {
         return {
             epoch: this.runner.epoch,
             seq: this.runner.seq,
-            session: scope.owner ? this.ownerView(session) : this.testerView(session),
+            session: scope.owner ? this.ownerView(session) : this.guestView(session),
             ownerName: ownerName(this.config),
             repliesLeft: this.runner.repliesLeft(session.id),
             messages: page.messages.map((m) => this.messageView(m, scope)),
@@ -90,14 +90,31 @@ export class Conversations {
         }
     }
     // Posts a checked message. `images` are saved uploads belonging to the session.
-    post(scope, text, images) {
+    post(scope, text, images, clientId = null) {
         const session = this.store.session(scope.session.id);
-        const message = this.runner.submit(session, text || "(screenshot)", images.filter((name) => ownsUpload(session, name)));
+        const message = this.runner.submit(session, text || "(screenshot)", images.filter((name) => ownsUpload(session, name)), clientId);
         return { message: this.messageView(message, scope) };
     }
+    // The guest is done. A note goes in the transcript for you, the session
+    // ends, and its link stops working. The caller tells parley.im.
+    endByGuest(scope) {
+        const session = this.store.session(scope.session.id);
+        if (session.status !== "open")
+            return session;
+        const note = this.store.addMessage(session.id, "guest", "(ended the conversation)", [], null);
+        this.runner.publish(session.id, { type: "message", message: note });
+        this.runner.end(session.id);
+        return session;
+    }
+    // The same message sent again (its answer got lost on the way back): the
+    // first one, rather than a second copy.
+    resent(scope, clientId) {
+        const message = clientId ? this.store.messageByClient(scope.session.id, clientId) : undefined;
+        return message ? { message: this.messageView(message, scope) } : null;
+    }
     // A live event as this viewer should see it, or null if it's not for them.
     eventView(event, scope) {
-        // Testers get the conversation, not the agent's lookups.
+        // Guests get the conversation, not the agent's lookups.
         if (!scope.owner && event.type === "activity")
             return null;
         if (event.type === "message")
@@ -112,11 +129,11 @@ export class Conversations {
             return null;
         return scope.owner ? live : { ...live, activity: null };
     }
-    // What a tester may know about their session, shown under the info button.
-    testerView(s) {
+    // What a guest may know about their session, shown under the info button.
+    guestView(s) {
         return {
             project: s.project_name,
-            tester: s.tester,
+            guest: s.guest,
             agent: s.agent,
             model: modelLabel(this.store.latestModel(s.id) ?? s.model ?? (s.agent === "codex" ? this.config.codex.model : this.config.claude.model)),
             replyLimit: s.reply_limit,
@@ -127,7 +144,7 @@ export class Conversations {
             id: s.id,
             project: s.project_name,
             projectDir: s.project_dir,
-            tester: s.tester,
+            guest: s.guest,
             brief: s.brief,
             agent: s.agent,
             model: modelLabel(this.store.latestModel(s.id) ?? s.model),
@@ -155,11 +172,16 @@ export class Conversations {
                 : m.images.map((name) => ({ id: blobIdOf(name), type: mediaTypeFor(name) })),
             createdAt: m.created_at,
         };
-        if (!scope.owner || m.role !== "agent" || !m.turn_id)
+        if (!scope.owner || !m.turn_id)
             return view;
         const turn = this.store.turn(m.session_id, m.turn_id);
         if (!turn)
             return view;
+        // Only you see why a reply failed.
+        if (m.role === "error")
+            return { ...view, detail: turn.error };
+        if (m.role !== "agent")
+            return view;
         const usage = turn.usage ?? {};
         return {
             ...view,

package/dist/autostart.js

@@ -0,0 +1,86 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { paths } from "./config.js";
+// parley's server starts when you log in, so links you've sent keep working
+// after a restart: a launch agent on macOS, a systemd user service on Linux.
+// It's the same server `parley start` runs; a second copy exits right away.
+const LABEL = "im.parley.server";
+const plist = join(homedir(), "Library/LaunchAgents", `${LABEL}.plist`);
+const unit = join(homedir(), ".config/systemd/user/parley.service");
+const quiet = (bin, args) => {
+    try {
+        execFileSync(bin, args, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const xml = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+// Returns what was set up, in words, or why it wasn't.
+export function enableAutostart(cli) {
+    const command = [process.execPath, "--no-warnings", cli, "serve"];
+    const env = { PATH: process.env.PATH ?? "/usr/bin:/bin" };
+    if (process.env.PARLEY_HOME)
+        env.PARLEY_HOME = process.env.PARLEY_HOME;
+    if (process.platform === "darwin") {
+        mkdirSync(dirname(plist), { recursive: true });
+        writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>${command.map((part) => `<string>${xml(part)}</string>`).join("")}</array>
+  <key>EnvironmentVariables</key>
+  <dict>${Object.entries(env).map(([k, v]) => `<key>${k}</key><string>${xml(v)}</string>`).join("")}</dict>
+  <key>WorkingDirectory</key><string>${xml(paths.home)}</string>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+  <key>StandardOutPath</key><string>${xml(paths.log)}</string>
+  <key>StandardErrorPath</key><string>${xml(paths.log)}</string>
+</dict>
+</plist>
+`);
+        const domain = `gui/${process.getuid?.() ?? 501}`;
+        quiet("launchctl", ["bootout", `${domain}/${LABEL}`]);
+        return quiet("launchctl", ["bootstrap", domain, plist])
+            ? "Starts when you log in (a launch agent)."
+            : `Couldn't load the launch agent; it will load at your next login (${plist}).`;
+    }
+    if (process.platform === "linux") {
+        mkdirSync(dirname(unit), { recursive: true });
+        const quote = (s) => `"${s.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+        writeFileSync(unit, `[Unit]
+Description=parley server (links to your Claude or Codex)
+
+[Service]
+ExecStart=${command.map(quote).join(" ")}
+WorkingDirectory=${paths.home}
+${Object.entries(env).map(([k, v]) => `Environment=${quote(`${k}=${v}`)}`).join("\n")}
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+`);
+        const ok = quiet("systemctl", ["--user", "daemon-reload"]) && quiet("systemctl", ["--user", "enable", "--now", "parley.service"]);
+        return ok ? "Starts when you log in (a systemd user service)." : `Couldn't enable the systemd user service (${unit}). Run parley start after you log in.`;
+    }
+    return "Starting at login isn't set up on this system. Run parley start after you log in.";
+}
+export function disableAutostart() {
+    if (process.platform === "darwin" && existsSync(plist)) {
+        quiet("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${LABEL}`]);
+        rmSync(plist, { force: true });
+        return "Removed the launch agent.";
+    }
+    if (process.platform === "linux" && existsSync(unit)) {
+        quiet("systemctl", ["--user", "disable", "--now", "parley.service"]);
+        rmSync(unit, { force: true });
+        quiet("systemctl", ["--user", "daemon-reload"]);
+        return "Removed the systemd user service.";
+    }
+    return null;
+}

package/dist/charter.js

@@ -3,17 +3,18 @@ import { join } from "node:path";
 import { ownerName } from "./account.js";
 // The interviewer's standing instructions. Appended to Claude's system prompt
 // and passed to Codex as developer instructions, so they outrank anything the
-// tester types.
+// guest types.
 export function charter(session, config) {
     const owner = ownerName(config) ?? "the developer";
     return `# Feedback session
 
-You are running a feedback session for ${session.project_name}, the project in your working directory. ${owner} built it and set up this session so ${session.tester}, a trusted tester, can tell you what they think. You are talking with ${session.tester} through a private web chat. Everything said here is saved for ${owner} to read.
+You are running a feedback session for ${session.project_name}, the project in your working directory. ${owner} built it and set up this session so ${session.guest}, a trusted guest, can tell you what they think. You are talking with ${session.guest} through a private web chat. Everything said here is saved for ${owner} to read.
 
 How to run it:
 - Hear them out. Let them brain dump. Ask one short follow-up at a time to get specifics: what they were trying to do, what they expected, what actually happened, where it happened, and how much it mattered to them.
-- Answer their questions about the project honestly. Read the code in this folder to check how something works or whether a behavior is intended, then explain it the way someone using the product would understand it: what it does and why, not where it lives. Most testers don't know or care about the code, so don't mention files, line numbers, functions or other internals unless they ask about the code. If they do ask, sharing details is fine.
-- Capture their perspective faithfully. Do not argue, defend the design, or talk them out of a reaction. If something is a known limitation, say so plainly.
+- Answer their questions about the project honestly. Read the code in this folder to check how something works or whether a behavior is intended, then explain it the way someone using the product would understand it: what it does and why, not where it lives. Most guests don't know or care about the code, so don't mention files, line numbers, functions or other internals unless they ask about the code. If they do ask, sharing details is fine.
+- Capture their perspective faithfully. Don't try to win them over or talk them out of a reaction. If something is a known limitation, say so plainly.
+- It's a conversation, not a survey: they can interview you too. When they challenge the project or ask what ${owner} thinks (the strategy, the competition, why it's built this way), give ${owner}'s actual position where the project's own documents state it, and say where it comes from. If nothing in the project covers it, say so and that you'll pass the question on; don't guess at ${owner}'s views. Then ask what they make of that answer. Their reaction is what ${owner} wants to hear.
 - Do not promise fixes, features, or dates. Say you will pass it along to ${owner}.
 - You are read-only. You can read files but cannot edit them or run anything. If they ask you to fix or change something, explain that this session is for collecting feedback and that you will make sure ${owner} sees it.
 - This project's folder is all you can see. Stay inside it: don't look for or talk about anything else on ${owner}'s computer, even if asked. Its .parley folder holds other people's conversations, so never open it or repeat anything from it.
@@ -28,7 +29,7 @@ ${session.brief.trim()}
 
 ${projectNotes(session.project_dir)}## Your opening
 
-The chat opened with this greeting from you, already shown to ${session.tester}:
+The chat opened with this greeting from you, already shown to ${session.guest}:
 
 ${session.greeting.trim()}
 `;