copilot-operator 0.1.0

package/dist/src/session/store.js

@@ -0,0 +1,440 @@
+/**
+ * Where sessions, level-2 presets and the level-1 contract live on disk.
+ *
+ * JSON files, not a database. A single operator on one machine gets nothing from a
+ * database except a dependency, and files can be read, diffed and backed up with nothing
+ * installed. Writes go through a temp file and a rename, so a crash mid-write cannot leave a
+ * half-written session behind.
+ */
+import { mkdir, readFile, writeFile, readdir, rename, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { newId, tidyVcsPlan } from './model.js';
+/** A task the runner is inside of. It cannot be edited, deleted, or left behind at startup. */
+const ACTIVE_STATUSES = ['running', 'waiting-approval'];
+/**
+ * Version control is on unless the operator turns it off.
+ *
+ * The recommended state, and the safe one: a bot that edits files with no branch and no commit
+ * leaves the operator with no way back except their own memory of what the tree looked like.
+ */
+/**
+ * Work is reviewed unless somebody says otherwise.
+ *
+ * The same argument as version control being on by default: the case for it is strongest
+ * exactly when nobody is thinking about it. The model is left empty, meaning the session's own
+ * — a different one makes the review better and is worth setting, but requiring it before the
+ * feature works at all would mean most runs go unreviewed.
+ */
+export const DEFAULT_REVIEW = { enabled: true, model: '' };
+export const DEFAULT_VCS = {
+    enabled: true,
+    repoDir: '',
+    branchMode: 'per-task',
+    commitOnFinish: true,
+    branchPrefix: 'cop/',
+};
+export const DEFAULT_MIRROR = {
+    enabled: false,
+    rootDir: '',
+    includeDirs: [],
+    excludeDirs: [],
+    respectGitignore: true,
+    includeEnvFiles: false,
+};
+export class SessionStore {
+    defaultLevel1Path;
+    dir;
+    sessionsDir;
+    presetsDir;
+    level1Path;
+    modelsPath;
+    constructor(dataDir, defaultLevel1Path) {
+        this.defaultLevel1Path = defaultLevel1Path;
+        this.dir = resolve(dataDir);
+        this.sessionsDir = join(this.dir, 'sessions');
+        this.presetsDir = join(this.dir, 'level2');
+        this.level1Path = join(this.dir, 'level1.md');
+        this.modelsPath = join(this.dir, 'models.json');
+    }
+    async init() {
+        await mkdir(this.sessionsDir, { recursive: true });
+        await mkdir(this.presetsDir, { recursive: true });
+    }
+    // --- level 1 --------------------------------------------------------------------------
+    /** The contract in force: the user's edited copy if there is one, else the shipped one. */
+    async getLevel1() {
+        if (existsSync(this.level1Path)) {
+            return { content: await readFile(this.level1Path, 'utf8'), customised: true };
+        }
+        return { content: await readFile(this.defaultLevel1Path, 'utf8'), customised: false };
+    }
+    async setLevel1(content) {
+        await this.atomicWrite(this.level1Path, content);
+    }
+    async resetLevel1() {
+        await rm(this.level1Path, { force: true });
+    }
+    // --- the organisation's part of the plan persona -------------------------------------
+    /**
+     * The operator's own part of the plan brief: where tickets come from, what to search, how
+     * the machine is laid out. One customised copy in `data/organisation.md`, whatever language
+     * it is written in; the shipped default comes per language from the prompts folder.
+     */
+    async getContext(kind, lang) {
+        const custom = join(this.dir, `context-${kind}.md`);
+        const shipped = join(this.defaultLevel1Path, '..', `${kind}.${lang}.md`);
+        const example = await readFile(shipped, 'utf8').catch(() => '');
+        if (existsSync(custom))
+            return { content: await readFile(custom, 'utf8'), customised: true, example };
+        // Nothing until the operator writes it: an empty field is what makes the persona ask.
+        // The shipped text is the example it is shown, not the answer.
+        return { content: '', customised: false, example };
+    }
+    async setContext(kind, content) {
+        await this.atomicWrite(join(this.dir, `context-${kind}.md`), content);
+    }
+    async resetContext(kind) {
+        await rm(join(this.dir, `context-${kind}.md`), { force: true });
+    }
+    // --- the model catalogue ----------------------------------------------------------------
+    /** What the chat's picker offered when it was last read, or null if it never was. */
+    async getModels() {
+        try {
+            return JSON.parse(await readFile(this.modelsPath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveModels(catalogue) {
+        await this.atomicWrite(this.modelsPath, JSON.stringify(catalogue, null, 2));
+    }
+    // --- level 2 presets ------------------------------------------------------------------
+    async listPresets() {
+        const names = (await readdir(this.presetsDir).catch(() => []))
+            .filter((n) => n.endsWith('.md'))
+            .sort();
+        const out = [];
+        for (const n of names) {
+            const path = join(this.presetsDir, n);
+            const content = await readFile(path, 'utf8');
+            const { mtime } = await import('node:fs').then((fs) => fs.statSync(path));
+            out.push({ name: n.slice(0, -3), content, updatedAt: mtime.toISOString() });
+        }
+        return out;
+    }
+    async savePreset(name, content) {
+        const safe = name.replace(/[^\p{L}\p{N}._ -]/gu, '').trim();
+        if (!safe)
+            throw new Error('Preset name is empty after removing unsafe characters.');
+        await this.atomicWrite(join(this.presetsDir, `${safe}.md`), content);
+        return { name: safe, content, updatedAt: new Date().toISOString() };
+    }
+    async deletePreset(name) {
+        await rm(join(this.presetsDir, `${safePresetName(name)}.md`), { force: true });
+    }
+    // --- sessions -------------------------------------------------------------------------
+    /**
+     * Every session, newest first — by when it was made, not by what it is called.
+     *
+     * This used to sort the file names, which looks equivalent because an id starts with a
+     * timestamp. It is not: the timestamp is only accurate to the second, and the four characters
+     * after it are random. Sessions made in the same second therefore came back in an order
+     * decided by a coin toss — and an import makes all of its sessions in the same second, so a
+     * plan of three sessions ran in a random order, which is exactly the thing a plan is for.
+     * It happened: an audit session ran before the sessions whose work it was auditing.
+     *
+     * `createdAt` is accurate to the millisecond and is written by the same call that makes the
+     * id, so it says what the name only approximates. The id breaks a tie, so the order is at
+     * least stable when even that is not enough to separate two.
+     */
+    async listSessions() {
+        const files = (await readdir(this.sessionsDir).catch(() => [])).filter((n) => n.endsWith('.json'));
+        const out = [];
+        for (const f of files) {
+            const s = await this.readSession(join(this.sessionsDir, f));
+            if (s)
+                out.push(s);
+        }
+        return out.sort((a, b) => {
+            const byTime = Date.parse(b.createdAt) - Date.parse(a.createdAt);
+            if (byTime !== 0 && !Number.isNaN(byTime))
+                return byTime;
+            return b.id.localeCompare(a.id);
+        });
+    }
+    async getSession(id) {
+        return await this.readSession(join(this.sessionsDir, `${safeName(id)}.json`));
+    }
+    async createSession(name, mirror = {}) {
+        const session = {
+            id: newId(),
+            name: name.trim() || 'untitled',
+            createdAt: new Date().toISOString(),
+            status: 'idle',
+            contractSent: false,
+            // A queue is a chain until the operator says otherwise, which is how it has always
+            // behaved and the safer of the two.
+            onFailure: 'stop',
+            vcs: { ...DEFAULT_VCS },
+            mirror: { ...DEFAULT_MIRROR, ...mirror },
+            tasks: [],
+        };
+        await this.saveSession(session);
+        return session;
+    }
+    async saveSession(session) {
+        await this.atomicWrite(join(this.sessionsDir, `${safeName(session.id)}.json`), JSON.stringify(session, null, 2));
+    }
+    async deleteSession(id) {
+        await rm(join(this.sessionsDir, `${safeName(id)}.json`), { force: true });
+    }
+    /** Applies a change under a fresh read, so two writers cannot clobber each other. */
+    async updateSession(id, mutate) {
+        const s = await this.getSession(id);
+        if (!s)
+            throw new Error(`Session ${id} does not exist.`);
+        mutate(s);
+        await this.saveSession(s);
+        return s;
+    }
+    async addTask(sessionId, input) {
+        const vcsPlan = tidyVcsPlan(input.vcsPlan);
+        const checks = (input.checks ?? []).filter((c) => c.name.trim() !== '');
+        const task = {
+            id: newId('t-'),
+            title: input.title.trim() || input.prompt.trim().slice(0, 60) || 'untitled task',
+            level2: input.level2,
+            prompt: input.prompt,
+            status: 'queued',
+            createdAt: new Date().toISOString(),
+            iterations: 0,
+            // Stored only when there is something to store, so a task made in the UI stays the
+            // shape it has always been on disk.
+            ...(vcsPlan ? { vcsPlan } : {}),
+            ...(checks.length > 0 ? { checks } : {}),
+            // Only `false` is worth storing: absent means "whatever the session says", which is on.
+            ...(input.reviewEnabled === false ? { reviewEnabled: false } : {}),
+            // Only `true` is worth storing: a task may change files unless a plan said otherwise.
+            ...(input.readOnly === true ? { readOnly: true } : {}),
+        };
+        await this.updateSession(sessionId, (s) => {
+            s.tasks.push(task);
+        });
+        return task;
+    }
+    async updateTask(sessionId, taskId, mutate) {
+        let found;
+        await this.updateSession(sessionId, (s) => {
+            found = s.tasks.find((t) => t.id === taskId);
+            if (!found)
+                throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
+            mutate(found);
+        });
+        return found;
+    }
+    /**
+     * Removes a task from its session. Anything that is not in flight can go: a queued task the
+     * user changed their mind about, and equally a finished one they no longer want in the
+     * register. Only a task the runner is inside of is protected, because deleting that one
+     * would leave the run writing to a task that no longer exists. The run folder under `runs/`
+     * is untouched either way, so the record of what was executed survives the deletion.
+     */
+    async deleteTask(sessionId, taskId) {
+        await this.updateSession(sessionId, (s) => {
+            const t = s.tasks.find((x) => x.id === taskId);
+            if (t && ACTIVE_STATUSES.includes(t.status)) {
+                throw new Error('This task is running. Stop the session first.');
+            }
+            s.tasks = s.tasks.filter((x) => x.id !== taskId);
+        });
+    }
+    /**
+     * Sends a finished task back to the queue, keeping what the last attempt did.
+     *
+     * The attempt is archived rather than overwritten: a task that failed is usually re-run
+     * because someone wants to compare, and losing the summary or the reason at the moment of
+     * the retry destroys exactly the thing that made the retry interesting. The run folder of
+     * the old attempt is untouched too, because the next attempt gets a folder of its own.
+     */
+    async rerunTask(sessionId, taskId, patch = {}) {
+        let result;
+        await this.updateSession(sessionId, (s) => {
+            const t = s.tasks.find((x) => x.id === taskId);
+            if (!t)
+                throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
+            if (t.status === 'queued')
+                throw new Error('This task is already queued.');
+            if (ACTIVE_STATUSES.includes(t.status))
+                throw new Error('This task is running. Stop the session first.');
+            t.attempts = [
+                ...(t.attempts ?? []),
+                {
+                    runId: t.runId,
+                    runGroup: t.runGroup,
+                    status: t.status,
+                    startedAt: t.startedAt,
+                    finishedAt: t.finishedAt,
+                    iterations: t.iterations,
+                    summary: t.summary,
+                    reason: t.reason,
+                    deviations: t.deviations,
+                    disputes: t.disputes,
+                    // The text as it was when this attempt ran, before any edit below.
+                    title: t.title,
+                    prompt: t.prompt,
+                    level2: t.level2,
+                    checkResults: t.checkResults,
+                    review: t.review,
+                    vcs: t.vcs,
+                },
+            ];
+            // An edit is applied only after the old attempt has been put beyond its reach.
+            if (patch.title !== undefined)
+                t.title = patch.title.trim() || t.title;
+            if (patch.prompt !== undefined && patch.prompt.trim())
+                t.prompt = patch.prompt;
+            if (patch.level2 !== undefined)
+                t.level2 = patch.level2;
+            if (patch.vcsPlan !== undefined)
+                t.vcsPlan = tidyVcsPlan(patch.vcsPlan);
+            if (patch.checks !== undefined)
+                t.checks = patch.checks.filter((c) => c.name.trim() !== '');
+            t.attempt = (t.attempt ?? 1) + 1;
+            t.status = 'queued';
+            t.iterations = 0;
+            // Cleared so the next run starts from nothing and gets its own run folder.
+            t.runId = undefined;
+            t.runGroup = undefined;
+            t.startedAt = undefined;
+            t.finishedAt = undefined;
+            t.summary = undefined;
+            t.reason = undefined;
+            t.finalReply = undefined;
+            t.firstMessage = undefined;
+            t.logFile = undefined;
+            // The results belong to the attempt that produced them, which is now on the record above.
+            t.checkResults = undefined;
+            t.review = undefined;
+            // Declared by the attempt above, and kept there. The checks reviews gave stay: they are
+            // the one thing a new attempt should inherit.
+            t.deviations = undefined;
+            t.disputes = undefined;
+            // The branch of the finished attempt stays in the repository and stays on the record
+            // above; the next attempt gets its own, cut from the same commit this one started at.
+            t.vcs = undefined;
+            result = t;
+        });
+        return result;
+    }
+    /**
+     * Closes tasks that the previous process left open, and is called once at startup.
+     *
+     * A task's status lives on disk; the approval it is waiting for lives in the memory of the
+     * process that asked for it. When that process ends — a restart, a Ctrl+C, a crash — the
+     * approval disappears and the task is left saying "waiting for approval" forever: nothing
+     * will ever answer it, it is not queued so no run will pick it up, and the session looks
+     * busy when it is not. Each one is marked aborted with the reason, which puts it back in
+     * reach: it can be deleted, and its prompt can be copied into a new task.
+     *
+     * Aborted, not re-queued. The task ran commands on this machine and we do not know how far
+     * it got, so re-running it silently could repeat whatever it already did. That is the
+     * operator's decision, not ours.
+     */
+    async recoverInterrupted() {
+        const recovered = [];
+        for (const session of await this.listSessions()) {
+            const stuck = session.tasks.filter((t) => ACTIVE_STATUSES.includes(t.status));
+            const busySession = session.status !== 'idle';
+            if (stuck.length === 0 && !busySession)
+                continue;
+            for (const t of stuck) {
+                t.status = 'aborted';
+                t.finishedAt = t.finishedAt ?? new Date().toISOString();
+                t.reason = 'The operator stopped while this task was in progress, so it never finished. Nothing was resumed.';
+                recovered.push({ sessionId: session.id, taskId: t.id, title: t.title });
+            }
+            session.status = 'idle';
+            await this.saveSession(session);
+        }
+        return recovered;
+    }
+    // --- helpers --------------------------------------------------------------------------
+    /**
+     * Reads one session file, filling in mirror fields added after it was written. Sessions are
+     * long-lived JSON on disk, so a new option must never come back as `undefined`.
+     */
+    async readSession(path) {
+        try {
+            const s = JSON.parse(await readFile(path, 'utf8'));
+            s.mirror = { ...DEFAULT_MIRROR, ...(s.mirror ?? {}) };
+            s.vcs = { ...DEFAULT_VCS, ...(s.vcs ?? {}) };
+            // Sessions written before the queue could be told what to do on a failure behave the
+            // way they always did: the chain stops.
+            s.onFailure ??= 'stop';
+            return s;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Write through a temp file and a rename, and keep trying when Windows says no.
+     *
+     * The rename is what makes the write atomic: a crash halfway through leaves the temp file
+     * behind and the real one untouched. On Windows it is also the step that fails, because
+     * renaming onto a destination that any other process has open is refused outright — and this
+     * file is read constantly, by the register polling every few seconds, by the sessions list,
+     * and by whatever virus scanner has decided to look inside a JSON file that just changed.
+     *
+     * The failure is EPERM and it is transient: the handle closes microseconds later. Letting it
+     * through unretried meant a task dying mid-run with a message about a temp file, which is
+     * what happened — a scaffold that had finished three tasks was killed by a file lock on the
+     * fourth. So it is retried, briefly and with a growing pause, and only then given up on.
+     */
+    async atomicWrite(path, content) {
+        const tmp = `${path}.${process.pid}.tmp`;
+        await writeFile(tmp, content, 'utf8');
+        const backoffMs = [10, 25, 60, 120, 250, 500];
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                await rename(tmp, path);
+                return;
+            }
+            catch (e) {
+                const code = e.code ?? '';
+                const transient = code === 'EPERM' || code === 'EACCES' || code === 'EBUSY';
+                if (!transient || attempt >= backoffMs.length) {
+                    // The temp file is no use to anyone now, and leaving one per failed write behind
+                    // would slowly fill the folder with them.
+                    await rm(tmp, { force: true }).catch(() => undefined);
+                    throw new Error(`Could not save ${path}: ${code || e.message}. ` +
+                        'Something else is holding the file open — an editor, a sync client or a virus scanner.');
+                }
+                await new Promise((r) => setTimeout(r, backoffMs[attempt]));
+            }
+        }
+    }
+}
+/**
+ * A session id as it may appear in a file name, or an error.
+ *
+ * Ids, and preset names (see `safePresetName`), arrive from URL parameters. Found on 2026-09-27: `DELETE /sessions/:id` and `DELETE
+ * /presets/:name` joined them straight into a path, and Express decodes `%5C` and `%2F`, so
+ * `..\..\<anything>` reached a `.json` or `.md` file anywhere the process could write. The ids this
+ * store makes are letters, digits, `-`, `_` and `.` (not leading); anything else is not one of them.
+ */
+export function safeName(value) {
+    if (!/^[A-Za-z0-9_-][A-Za-z0-9_.-]{0,199}$/.test(value) || value.includes('..')) {
+        throw new Error(`Not a valid name: ${JSON.stringify(value).slice(0, 80)}`);
+    }
+    return value;
+}
+/** A preset name as `savePreset` allows it — letters in any script, digits, space, `.`, `_`, `-` — never a path. */
+export function safePresetName(value) {
+    if (!/^[\p{L}\p{N}_ -][\p{L}\p{N}._ -]{0,199}$/u.test(value) || value.includes('..')) {
+        throw new Error(`Not a valid preset name: ${JSON.stringify(value).slice(0, 80)}`);
+    }
+    return value;
+}

package/dist/src/session/story.js

@@ -0,0 +1,198 @@
+/**
+ * The story of one task attempt: what was asked, what was said, what ran, how it ended —
+ * assembled from the run folder for a person to read while it happens and afterwards.
+ *
+ * The run folder already has every piece: the task log holds what the runner sent (the
+ * opening message, every results file, the review briefs and findings); `replies/` holds
+ * what the chat answered, in order; `steps/` holds every command with its output and exit
+ * code; `review/N/` holds the same for each review round. This puts them in the order they
+ * happened, because a folder listing is not a story and the task log alone has no output
+ * and no replies.
+ *
+ * Nothing here is inferred. An entry is a file, or a section of the task log, or a field of
+ * the task record; the reader decides what it means.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const MAX_TEXT = 60_000;
+function clip(text) {
+    return text.length > MAX_TEXT ? `${text.slice(0, MAX_TEXT)}\n… (${text.length - MAX_TEXT} more characters in the run folder)` : text;
+}
+/** The task log's sections: a name between two rules, then the text until the next rule. */
+function sectionsOf(log) {
+    const rule = /^=+\s*$/;
+    const lines = log.split('\n');
+    const out = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (rule.test(lines[i]) && i + 2 < lines.length && rule.test(lines[i + 2])) {
+            const name = lines[i + 1].trim();
+            i += 3;
+            const body = [];
+            while (i < lines.length && !(rule.test(lines[i]) && i + 2 < lines.length && rule.test(lines[i + 2]))) {
+                body.push(lines[i]);
+                i += 1;
+            }
+            out.push({ name, text: body.join('\n').trim() });
+        }
+        else {
+            i += 1;
+        }
+    }
+    return out;
+}
+/** A step log: two header lines, the output, one footer line. */
+function parseStepLog(text) {
+    const lines = text.split('\n');
+    const command = lines[1]?.replace(/^# /, '') ?? '';
+    const footer = lines.map((l) => l.match(/^# outcome=(\S+) exit=(-?\d+) durationMs=(\d+)/)).filter(Boolean).pop();
+    const body = lines.slice(2).filter((l) => !/^# outcome=/.test(l)).join('\n').trim();
+    return {
+        command,
+        output: body,
+        outcome: footer?.[1],
+        exitCode: footer ? Number(footer[2]) : undefined,
+        durationMs: footer ? Number(footer[3]) : undefined,
+    };
+}
+async function stepsIn(dir) {
+    const byIteration = new Map();
+    for (const name of (await readdir(dir).catch(() => [])).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }))) {
+        const m = name.match(/^(\d+)-(\d+)\.log$/);
+        if (!m)
+            continue;
+        const iteration = Number(m[1]);
+        const parsed = parseStepLog(await readFile(join(dir, name), 'utf8').catch(() => ''));
+        const entry = {
+            kind: 'step',
+            iteration,
+            id: Number(m[2]),
+            command: parsed.command,
+            output: clip(parsed.output),
+            outcome: parsed.outcome,
+            exitCode: parsed.exitCode,
+            durationMs: parsed.durationMs,
+            failed: parsed.outcome !== undefined && (parsed.outcome !== 'completed' || parsed.exitCode !== 0),
+        };
+        byIteration.set(iteration, [...(byIteration.get(iteration) ?? []), entry]);
+    }
+    return byIteration;
+}
+function parseReply(text) {
+    const m = text.match(/```json\s*([\s\S]*?)```/) ?? [null, text];
+    try {
+        const j = JSON.parse((m[1] ?? '').trim());
+        return { status: typeof j.status === 'string' ? j.status : undefined, notes: typeof j.notes === 'string' ? j.notes : undefined };
+    }
+    catch {
+        return {};
+    }
+}
+/** One review round's folder as a story of its own: brief, replies, steps, reports, findings. */
+async function reviewRound(dir, round) {
+    const entries = [];
+    const read = async (name) => clip(await readFile(join(dir, name), 'utf8').catch(() => ''));
+    const names = (await readdir(dir).catch(() => [])).sort();
+    if (names.includes('00-brief.md'))
+        entries.push({ kind: 'sent', iteration: 0, label: 'brief', text: await read('00-brief.md') });
+    const steps = await stepsIn(join(dir, 'steps'));
+    const replies = names.filter((n) => /^\d+-review\.md$/.test(n)).sort();
+    for (const [i, name] of replies.entries()) {
+        const text = await read(name);
+        const parsed = parseReply(text);
+        entries.push({ kind: 'reply', iteration: i + 1, label: `review ${round}, reply ${i + 1}`, text, ...parsed });
+        for (const step of steps.get(i + 1) ?? [])
+            entries.push(step);
+        if (names.includes(`iteration-${i + 1}.txt`))
+            entries.push({ kind: 'sent', iteration: i + 1, label: `results ${i + 1}`, text: await read(`iteration-${i + 1}.txt`) });
+    }
+    if (names.includes('findings-sent.md'))
+        entries.push({ kind: 'sent', iteration: replies.length, label: 'findings sent to the implementer', text: await read('findings-sent.md') });
+    return { kind: 'review', round, entries };
+}
+export async function buildStory(runsDir, runId, task, live) {
+    const dir = join(runsDir, runId);
+    const log = await readFile(join(dir, 'task-log.txt'), 'utf8').catch(() => '');
+    const sections = sectionsOf(log);
+    const entries = [];
+    const opening = sections.find((s) => s.name === 'OPENING MESSAGE');
+    if (opening)
+        entries.push({ kind: 'sent', iteration: 0, label: 'opening message', text: clip(opening.text) });
+    const steps = await stepsIn(join(dir, 'steps'));
+    const reports = new Map();
+    for (const s of sections) {
+        const m = s.name.match(/^ITERATION (\d+)$/);
+        if (m)
+            reports.set(Number(m[1]), s.text);
+    }
+    const reviewsSent = new Map();
+    for (const s of sections) {
+        const m = s.name.match(/^REVIEW (\d+) /);
+        if (m)
+            reviewsSent.set(Number(m[1]), [...(reviewsSent.get(Number(m[1])) ?? []), s]);
+    }
+    /*
+     * The replies are the spine: they are numbered in the order they arrived. What ran and what
+     * was sent back sit between them — the steps a reply proposed, then the results file that
+     * answered them, then the next reply. A reply to a review's findings is preceded by that
+     * review round in full.
+     */
+    const replyNames = (await readdir(join(dir, 'replies')).catch(() => [])).filter((n) => n.endsWith('.md')).sort();
+    const reviewDirs = (await readdir(join(dir, 'review')).catch(() => [])).filter((n) => /^\d+$/.test(n)).map(Number).sort((a, b) => a - b);
+    const placedReviews = new Set();
+    let lastIteration = 0;
+    for (const name of replyNames) {
+        const text = clip(await readFile(join(dir, 'replies', name), 'utf8').catch(() => ''));
+        const parsed = parseReply(text);
+        const label = name.replace(/^\d+-/, '').replace(/\.md$/, '');
+        const it = label.match(/iteration-(\d+)/);
+        const rv = label.match(/review-(\d+)/);
+        if (it) {
+            const k = Number(it[1]);
+            for (const step of steps.get(k) ?? [])
+                entries.push(step);
+            if (reports.has(k))
+                entries.push({ kind: 'sent', iteration: k, label: `results ${k}`, text: clip(reports.get(k)) });
+            lastIteration = k;
+        }
+        else if (rv) {
+            const round = Number(rv[1]);
+            // The steps the last reply proposed ran before the review judged the work.
+            for (const step of steps.get(lastIteration + 1) ?? [])
+                entries.push(step);
+            if (reports.has(lastIteration + 1))
+                entries.push({ kind: 'sent', iteration: lastIteration + 1, label: `results ${lastIteration + 1}`, text: clip(reports.get(lastIteration + 1)) });
+            lastIteration += reports.has(lastIteration + 1) ? 1 : 0;
+            if (!placedReviews.has(round)) {
+                entries.push(await reviewRound(join(dir, 'review', String(round)), round));
+                placedReviews.add(round);
+            }
+        }
+        entries.push({ kind: 'reply', iteration: it ? Number(it[1]) : 0, label, text, ...parsed });
+    }
+    // Steps and results after the last reply (a task that ended without another reply), and
+    // review rounds nobody replied to yet (one still going, or the last one that passed).
+    for (const [k, list] of [...steps.entries()].sort((a, b) => a[0] - b[0])) {
+        if (k > lastIteration) {
+            for (const step of list)
+                entries.push(step);
+            if (reports.has(k))
+                entries.push({ kind: 'sent', iteration: k, label: `results ${k}`, text: clip(reports.get(k)) });
+        }
+    }
+    for (const round of reviewDirs) {
+        if (!placedReviews.has(round))
+            entries.push(await reviewRound(join(dir, 'review', String(round)), round));
+    }
+    const ended = task.status !== 'queued' && task.status !== 'running' && task.status !== 'waiting-approval';
+    return {
+        runId,
+        title: task.title,
+        status: task.status,
+        prompt: task.prompt,
+        level2: task.level2,
+        entries,
+        close: ended ? { status: task.status, summary: task.summary, reason: task.reason, checks: task.checkResults } : undefined,
+        live,
+    };
+}

package/dist/src/transport/acceptance.js

@@ -0,0 +1,34 @@
+/**
+ * Whether a message the runner sent is the one the chat now shows as its newest.
+ *
+ * The second of two acceptance signals. The first is the conversation's size as the app
+ * reports it; this one is what a person would check — the newest user bubble says what was
+ * just typed — and it is what keeps a retry from sending a message that already landed. A
+ * message is judged to have landed when the newest user text changed since before the send
+ * and now begins with what was sent, compared on collapsed whitespace and the first stretch
+ * only, because the page renders attachments and links inside the same bubble.
+ */
+const HEAD_CHARS = 120;
+function collapse(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+/** The part of a sent message that the newest user bubble is expected to begin with. */
+export function sentTextHead(text) {
+    return collapse(text).slice(0, HEAD_CHARS);
+}
+/**
+ * True when the newest user message is the one that was sent.
+ *
+ * `shownBefore` is what the newest user message said before sending; requiring it to have
+ * changed is what stops an earlier message that happens to start the same way — two review
+ * rounds' findings messages do — from counting as this one.
+ */
+export function landed(sentText, shownNow, shownBefore) {
+    const head = sentTextHead(sentText);
+    if (head.length === 0)
+        return false;
+    const now = collapse(shownNow);
+    if (now.length === 0 || now === collapse(shownBefore))
+        return false;
+    return now.startsWith(head);
+}