@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/server/modules/agent/jobs.js

@@ -0,0 +1,316 @@
+import { randomUUID } from "node:crypto";
+import { createApprovalBridge, createQuestionBridge, completeCommandRequest, } from "./command-bridge.js";
+import { createRun, readRun, removeRun, stopRun, trackRun } from "./agent-runs.js";
+import { changedSince, snapshotGit } from "./jobs-files.js";
+import { resolveJudgeSettings } from "../../../core/modules/agent-judge/index.js";
+import { createJudgedApproval, readJudgeSettings } from "../judge/index.js";
+import { readChatJudge } from "./judge-store.js";
+import { RESULT_LIMIT, change, dropPending, flushJournal, isFinished, live, onEvent, persist, record, wake, } from "./jobs-live.js";
+import { JOB_RETAIN_MS, jobIds, loadJob, loadJournal, newJobId, publicJob, removeJobFiles, saveJob, } from "./jobs-store.js";
+import { runAgent } from "./registry.js";
+export { isFinished } from "./jobs-live.js";
+/** A request nobody answered is refused after this long. */
+const ANSWER_TIMEOUT_MS = 2 * 60 * 60 * 1000;
+const clip = (text) => (text.length > RESULT_LIMIT ? text.slice(0, RESULT_LIMIT) : text);
+async function finish(entry) {
+    const { job } = entry;
+    const status = entry.stopping ? "stopped" : entry.failure ? "error" : "done";
+    job.result = clip((entry.final ?? entry.collected).trim());
+    if (job.history?.at(-1)?.role === "user")
+        job.history.push({ role: "assistant", content: job.result.slice(0, 20_000) });
+    if (entry.failure && !entry.stopping)
+        job.error = entry.failure;
+    job.pending = [];
+    const changed = await changedSince(job.cwd, entry.snapshot);
+    job.files = [...new Set([...job.files, ...changed, ...entry.touched])].sort().slice(0, 500);
+    job.endedAt = Date.now();
+    if (job.runId)
+        await removeRun(job.runId).catch(() => { });
+    change(entry, status);
+    await persist(entry);
+    await flushJournal(entry);
+    live.delete(job.id);
+    wake(entry);
+}
+export async function drive(entry, attach, message = entry.job.task, history = []) {
+    const { job } = entry;
+    let untrack;
+    try {
+        let run;
+        if (attach) {
+            run = job.runId ? await readRun(job.runId) : null;
+            if (!run)
+                throw new Error("Ход задания потерян при перезапуске сервера");
+        }
+        else {
+            run = {
+                backend: job.backend,
+                message,
+                history,
+                cwd: job.cwd,
+                selection: job.selection,
+                role: job.role,
+                permissionMode: job.permissionMode,
+                approvals: true,
+                projectId: job.projectId,
+                chat: `job:${job.id}`,
+                messageId: job.messageId,
+                ...(job.sessionId ? { sessionId: job.sessionId } : {}),
+            };
+            job.runId = await createRun(run);
+            job.startedAt = Date.now();
+            entry.snapshot = await snapshotGit(job.cwd);
+            if (entry.snapshot) {
+                if (entry.snapshot.head)
+                    job.base = entry.snapshot.head;
+                job.dirty = [...entry.snapshot.dirty.keys()];
+            }
+            await persist(entry);
+        }
+        untrack = trackRun(job.runId, () => entry.abort.abort());
+        change(entry, "running");
+        const emit = (event, data) => onEvent(entry, event, data);
+        await runAgent({
+            ...run,
+            backend: job.backend,
+            run: { id: job.runId, attach },
+            approve: async (request) => {
+                if (job.unattended) {
+                    record(entry, "answer", { auto: true, tool: request.tool, title: request.title });
+                    return true;
+                }
+                let id = "";
+                const bridge = createApprovalBridge((name, data) => {
+                    id = String(data.id ?? "");
+                    emit(name, data);
+                }, entry.abort.signal, ANSWER_TIMEOUT_MS);
+                const approve = createJudgedApproval({
+                    approve: bridge,
+                    emit: (event, data) => emit(event, data),
+                    settings: resolveJudgeSettings(await readJudgeSettings(), job.origin ? readChatJudge(job.origin) : undefined),
+                    cwd: job.cwd,
+                    backend: job.backend,
+                    signal: entry.abort.signal,
+                });
+                try {
+                    return await approve(request);
+                }
+                catch {
+                    return false;
+                }
+                finally {
+                    if (id)
+                        dropPending(entry, id);
+                }
+            },
+            ask: async (request) => {
+                if (job.unattended)
+                    return null;
+                let id = "";
+                const bridge = createQuestionBridge((name, data) => {
+                    id = String(data.id ?? "");
+                    emit(name, data);
+                }, entry.abort.signal, ANSWER_TIMEOUT_MS);
+                try {
+                    return await bridge(request);
+                }
+                catch {
+                    return null;
+                }
+                finally {
+                    if (id)
+                        dropPending(entry, id);
+                }
+            },
+            abort: entry.abort.signal,
+            emit,
+        });
+    }
+    catch (error) {
+        if (!entry.stopping)
+            entry.failure = error instanceof Error ? error.message : "Ошибка агента";
+    }
+    finally {
+        untrack?.();
+    }
+    if (entry.stopping && job.runId)
+        await stopRun(job.runId).catch(() => { });
+    // The final status becomes visible inside finish before its writes are done. Keep the promise
+    // so a removal that sees that status can wait instead of racing the writes or the live entry.
+    entry.finalizing = finish(entry);
+    await entry.finalizing;
+}
+export function open(job, journal) {
+    const entry = {
+        job,
+        journal,
+        abort: new AbortController(),
+        waiters: new Set(),
+        stopping: false,
+        collected: "",
+        touched: new Set(),
+    };
+    live.set(job.id, entry);
+    return entry;
+}
+/** Creates a job and starts its agent without waiting for the answer. */
+export async function startJob(input) {
+    const job = {
+        id: newJobId(),
+        backend: input.backend,
+        task: input.task,
+        projectId: input.projectId,
+        cwd: input.cwd,
+        ...(input.worktree ? { worktree: input.worktree } : {}),
+        history: [{ role: "user", content: input.task }],
+        ...(input.origin ? { origin: input.origin } : {}),
+        messageId: randomUUID(),
+        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        ...(input.role ? { role: input.role } : {}),
+        ...(input.selection ? { selection: input.selection } : {}),
+        ...(input.permissionMode ? { permissionMode: input.permissionMode } : {}),
+        unattended: input.unattended === true,
+        status: "queued",
+        rev: 1,
+        createdAt: Date.now(),
+        result: "",
+        files: [],
+        pending: [],
+    };
+    const entry = open(job, []);
+    await persist(entry);
+    void drive(entry, false);
+    return publicJob(job);
+}
+/** Rejoins the jobs an earlier server left running; each one is taken over only once. */
+export function recoverJobs() {
+    // Two calls at once share one pass: a job that already ended must not be read half-written.
+    recovery ??= collect().finally(() => (recovery = undefined));
+    return recovery;
+}
+let recovery;
+async function collect() {
+    for (const id of await jobIds()) {
+        if (live.has(id))
+            continue;
+        const job = await loadJob(id);
+        if (!job)
+            continue;
+        if (isFinished(job.status)) {
+            if (Date.now() - (job.endedAt ?? job.createdAt) > JOB_RETAIN_MS)
+                await removeJobFiles(id).catch(() => { });
+            continue;
+        }
+        job.pending = [];
+        job.status = "queued";
+        // Registered before anything else is awaited: a second recovery must find it taken.
+        const entry = open(job, []);
+        entry.journal = await loadJournal(id);
+        void drive(entry, !!job.runId);
+    }
+}
+const summarize = (job) => {
+    const { result, history: _history, ...rest } = job;
+    return { ...rest, resultPreview: result.slice(0, 300) };
+};
+/** The jobs of all projects (or one), newest first, without their journals. */
+export async function listJobs(projectId) {
+    const jobs = await Promise.all((await jobIds()).map(async (id) => live.get(id)?.job ?? (await loadJob(id))));
+    return jobs
+        .filter((job) => !!job && (!projectId || job.projectId === projectId))
+        .sort((a, b) => b.createdAt - a.createdAt)
+        .map((job) => summarize(structuredClone(job)));
+}
+export async function readJob(id) {
+    const entry = live.get(id);
+    if (entry)
+        return { job: publicJob(entry.job), journal: structuredClone(entry.journal) };
+    const job = await loadJob(id);
+    return job ? { job: publicJob(job), journal: await loadJournal(id) } : null;
+}
+/** Resolves when the job's `rev` passes `rev`, or after `seconds` (at most 45). */
+export async function waitForJob(id, rev, seconds) {
+    const entry = live.get(id);
+    if (entry && entry.job.rev <= rev && seconds > 0) {
+        await new Promise((resolve) => {
+            const done = () => {
+                clearTimeout(timer);
+                entry.waiters.delete(done);
+                resolve();
+            };
+            const timer = setTimeout(done, Math.min(seconds, 45) * 1000);
+            entry.waiters.add(done);
+        });
+    }
+    return readJob(id);
+}
+export async function stopJob(id) {
+    const entry = live.get(id);
+    if (!entry) {
+        const job = await loadJob(id);
+        if (job && !isFinished(job.status)) {
+            job.status = "stopped";
+            job.rev++;
+            job.pending = [];
+            job.endedAt = Date.now();
+            if (job.runId) {
+                await stopRun(job.runId).catch(() => { });
+                await removeRun(job.runId).catch(() => { });
+            }
+            await saveJob(job);
+        }
+        return job ? publicJob(job) : null;
+    }
+    entry.stopping = true;
+    entry.abort.abort();
+    return publicJob(entry.job);
+}
+/** Sends the user's answer to the request the agent waits on; the run goes on. */
+export async function answerJob(id, answer) {
+    const entry = live.get(id);
+    if (!entry)
+        throw new Error("Задание не ждёт ответа");
+    const card = answer.request
+        ? entry.job.pending.find((item) => item.id === answer.request)
+        : entry.job.pending[0];
+    if (!card)
+        throw new Error("У задания нет запроса, ожидающего ответа");
+    let output;
+    let summary;
+    if (card.kind === "permission") {
+        if (typeof answer.allow !== "boolean")
+            throw new Error("Разрешение подтверждает пользователь карточкой в чате Projector");
+        const allow = answer.allow;
+        const always = answer.always === true;
+        output = { allow, always: allow && always };
+        summary = allow ? (always ? "разрешено всегда" : "разрешено") : "отклонено";
+    }
+    else {
+        let answers = answer.answers;
+        if (answers === undefined) {
+            const first = card.questions?.[0];
+            const text = answer.text?.trim();
+            answers = first && text ? { [first.id]: [text] } : null;
+        }
+        output = { answers };
+        summary = answers ? JSON.stringify(answers) : "пропущено";
+    }
+    if (!completeCommandRequest(card.id, { output })) {
+        dropPending(entry, card.id);
+        throw new Error("Запрос уже неактуален");
+    }
+    record(entry, "answer", { id: card.id, kind: card.kind, summary });
+    dropPending(entry, card.id);
+    return publicJob(entry.job);
+}
+export async function removeJob(id) {
+    const entry = live.get(id);
+    if (entry) {
+        if (!isFinished(entry.job.status))
+            throw new Error("Задание ещё работает: сначала остановите его");
+        // A finished job is still live while its final record and journal are written: let that
+        // finish, then remove the files, so nothing is deleted halfway or recreated afterwards.
+        await entry.finalizing;
+    }
+    await removeJobFiles(id);
+}

package/packages/server/modules/agent/judge-store.js

@@ -0,0 +1,21 @@
+import { normalizeJudgeOverride, } from "../../../core/modules/agent-judge/index.js";
+import { historyDatabase } from "./history-store.js";
+/** The chat's own Judge settings; absent means the global ones apply. */
+export function readChatJudge(chat) {
+    const db = historyDatabase();
+    const row = db.prepare("SELECT judge FROM chats WHERE id = ?").get(chat);
+    if (!row?.judge)
+        return undefined;
+    try {
+        return normalizeJudgeOverride(JSON.parse(row.judge));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Replaces the chat's Judge override; `null` returns it to the global settings. */
+export function saveChatJudge(chat, judge) {
+    const db = historyDatabase();
+    db.prepare(`INSERT INTO chats (id, judge) VALUES (?, ?)
+     ON CONFLICT (id) DO UPDATE SET judge = excluded.judge`).run(chat, judge ? JSON.stringify(judge) : null);
+}

package/packages/server/modules/agent/lens-request.js

@@ -0,0 +1,34 @@
+import { asString } from "../transport/index.js";
+import { selectionFrom } from "./controls.js";
+import { historyFrom, planItemsFrom, runningToolsFrom, } from "./side-request.js";
+const HISTORY_TURNS = 40;
+const RUNNING_TOOLS = 12;
+const PLAN_ITEMS = 30;
+const PHASE_CHARS = 200;
+const QUEUE_LIMIT = 99;
+/** Keep the newest turns for the prompt, starting at a user turn so no answer is orphaned. */
+function tail(turns) {
+    const start = Math.max(0, turns.length - HISTORY_TURNS);
+    let at = start;
+    while (at < turns.length && turns[at].role !== "user")
+        at++;
+    return turns.slice(at);
+}
+/** A Lens request from `POST /api/agent/lens`; malformed parts are dropped, sizes bounded. */
+export function lensRequestFrom(body) {
+    const state = body.state && typeof body.state === "object" && !Array.isArray(body.state)
+        ? body.state
+        : {};
+    const queue = state.queue;
+    return {
+        history: tail(historyFrom(body.history)),
+        busy: state.busy === true,
+        phase: asString(state.phase).slice(0, PHASE_CHARS),
+        running: runningToolsFrom(state.running).slice(0, RUNNING_TOOLS),
+        plan: planItemsFrom(state.plan).slice(0, PLAN_ITEMS),
+        queue: typeof queue === "number" && Number.isFinite(queue) && queue > 0
+            ? Math.min(Math.floor(queue), QUEUE_LIMIT)
+            : 0,
+        selection: selectionFrom(body.selection),
+    };
+}

package/packages/server/modules/agent/queue-store.js

@@ -0,0 +1,21 @@
+import { historyDatabase } from "./history-store.js";
+/** The messages waiting for the answer, saved with the chat; absent for a chat without a queue. */
+export function readChatQueue(chat) {
+    const row = historyDatabase().prepare("SELECT queue FROM chats WHERE id = ?").get(chat);
+    if (!row?.queue)
+        return undefined;
+    try {
+        const value = JSON.parse(row.queue);
+        return Array.isArray(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Replaces the messages waiting for the answer; an empty queue is stored as none at all. */
+export function saveChatQueue(chat, queue) {
+    historyDatabase()
+        .prepare(`INSERT INTO chats (id, queue) VALUES (?, ?)
+       ON CONFLICT (id) DO UPDATE SET queue = excluded.queue`)
+        .run(chat, queue?.length ? JSON.stringify(queue) : null);
+}

package/packages/server/modules/agent/recent-chats.js

@@ -0,0 +1,63 @@
+import { currentSession, deleteHistory, historyDatabase, loadHistory } from "./history-store.js";
+import { readChatRole } from "./role-store.js";
+/** The native session saved with a chat, for rows created before the index stored it. */
+function sessionFromHistory(chat) {
+    const turns = loadHistory(chat);
+    return turns ? currentSession(turns) : undefined;
+}
+/** Chats of a project, newest first: open in a tab or closed with their history still on disk. */
+export function readRecentChats(project, backend, limit = 50) {
+    if (!project)
+        return [];
+    const db = historyDatabase();
+    // The project's own conversation (key = project) has no tab command to reopen it; it is opened
+    // by the workspace itself and is left out of the list.
+    const rows = (backend
+        ? db
+            .prepare("SELECT chat, backend, title, updated, session FROM chat_index WHERE scope = ? AND chat <> scope AND backend = ? ORDER BY updated DESC LIMIT ?")
+            .all(project, backend, limit)
+        : db
+            .prepare("SELECT chat, backend, title, updated, session FROM chat_index WHERE scope = ? AND chat <> scope ORDER BY updated DESC LIMIT ?")
+            .all(project, limit));
+    const remember = db.prepare("UPDATE chat_index SET session = ? WHERE chat = ?");
+    return rows.map((row) => {
+        // Rows written before the index knew sessions get theirs from the saved turns, once.
+        const session = row.session ?? sessionFromHistory(row.chat);
+        if (!row.session && session)
+            remember.run(session, row.chat);
+        const role = readChatRole(row.chat);
+        return {
+            chat: row.chat,
+            backend: row.backend,
+            title: row.title,
+            updatedAt: row.updated,
+            ...(session ? { session } : {}),
+            ...(role ? { role } : {}),
+        };
+    });
+}
+/**
+ * Forgets the chats that continued a native session which was just deleted: otherwise each of
+ * them would come back as a separate, undeletable copy of the removed conversation.
+ * `keep` is the chat asking for the deletion: its own tab stays as it is.
+ */
+export function removeChatsWithSession(project, backend, session, keep = "") {
+    if (!project)
+        return [];
+    const rows = historyDatabase()
+        .prepare("SELECT chat FROM chat_index WHERE scope = ? AND backend = ? AND session = ? AND chat <> ?")
+        .all(project, backend, session, keep);
+    for (const row of rows)
+        deleteHistory(row.chat);
+    return rows.map((row) => row.chat);
+}
+/** Removes a chat of this project with its saved turns; a tab that is open keeps its screen. */
+export function forgetChat(project, chat) {
+    if (!project || !chat)
+        return false;
+    const row = historyDatabase().prepare("SELECT scope FROM chat_index WHERE chat = ?").get(chat);
+    if (!row || row.scope !== project)
+        return false;
+    deleteHistory(chat);
+    return true;
+}

package/packages/server/modules/agent/registry.js

@@ -0,0 +1,108 @@
+import { preferences } from "../preferences/index.js";
+import { removeChatsWithSession } from "./recent-chats.js";
+export { selectionFrom } from "./controls.js";
+const backends = new Map();
+let defaultId;
+/**
+ * Adds an agent to the chat under the id it declares; registering the same id again replaces it.
+ * The first backend registered with `asDefault` answers the requests that name no agent.
+ */
+export function registerAgentBackend(backend, options = {}) {
+    backends.set(backend.id, backend);
+    if (options.asDefault || defaultId === undefined)
+        defaultId = backend.id;
+}
+/** Every registered backend in registration order, without its methods. */
+export function listAgentBackends() {
+    return [...backends.values()].map(({ id, label, program, terminal, builtin, capabilities }) => ({
+        id,
+        label,
+        ...(program ? { program } : {}),
+        ...(terminal ? { terminal } : {}),
+        ...(builtin ? { builtin } : {}),
+        ...(capabilities ? { capabilities } : {}),
+    }));
+}
+/** Whether a request names an agent this server has registered. */
+export function isAgentBackend(id) {
+    return typeof id === "string" && backends.has(id);
+}
+/** The agent a request runs with: the one it names, else the default. */
+export function resolveAgentBackend(id) {
+    if (isAgentBackend(id))
+        return id;
+    if (defaultId === undefined)
+        throw new Error("Ни один агент не зарегистрирован");
+    return defaultId;
+}
+function backendFor(id) {
+    const backend = backends.get(id ?? defaultId ?? "");
+    if (!backend)
+        throw new Error(`Неизвестный агент: ${id}`);
+    return backend;
+}
+/** Whether the agent's run lives in its own host process, so it survives a server restart. */
+export function isHostedAgent(id) {
+    return backendFor(id).capabilities?.hosted === true;
+}
+/** Whether the agent can start here: its program is installed (unknown counts as yes). */
+export function isAgentAvailable(id) {
+    return backendFor(id).available?.() !== false;
+}
+/** Method-backed operations are derived from the adapter, never its name. */
+export function agentCapabilities(id) {
+    const backend = backendFor(id);
+    return {
+        ...backend.capabilities,
+        rewindFiles: !!backend.rewindFiles,
+        editSessions: !!backend.updateSession,
+        deleteSessions: backend.capabilities?.deleteSessions ?? !!backend.deleteSession,
+    };
+}
+/** Model, effort and mode choices the agent offers; empty for agents without any. */
+export async function agentControls(id, cwd) {
+    return (await backendFor(id).controls?.(cwd)) ?? [];
+}
+export async function agentCommands(id, cwd) {
+    return (await backendFor(id).commands?.(cwd)) ?? [];
+}
+export async function rewindAgentFiles(id, cwd, sessionId, messageId, dryRun) {
+    const backend = backendFor(id);
+    if (!backend.rewindFiles)
+        throw new Error("Этот агент не умеет возвращать файлы к прошлому шагу");
+    return backend.rewindFiles(cwd, sessionId, messageId, dryRun);
+}
+export async function updateAgentSession(id, cwd, sessionId, change) {
+    const backend = backendFor(id);
+    if (!backend.updateSession)
+        throw new Error("Этот агент не умеет переименовывать сессии");
+    await backend.updateSession(cwd, sessionId, change);
+}
+export async function deleteAgentSession(id, cwd, sessionId, history) {
+    const backend = backendFor(id);
+    if (!backend.deleteSession)
+        throw new Error("Этот агент не умеет удалять сессии");
+    await backend.deleteSession(cwd, sessionId);
+    // The chats that continued the session are the same conversation: remove their copies too.
+    if (history?.project)
+        removeChatsWithSession(history.project, backend.id, sessionId, history.keep);
+}
+export async function agentMcpServers(id, cwd) {
+    return (await backendFor(id).mcpServers?.(cwd)) ?? [];
+}
+export async function agentSessions(id, cwd) {
+    return (await backendFor(id).sessions?.(cwd)) ?? [];
+}
+export async function loadAgentSession(id, cwd, sessionId) {
+    const backend = backendFor(id);
+    if (!backend.loadSession)
+        throw new Error("Агент не умеет восстанавливать прошлые сессии");
+    return backend.loadSession(cwd, sessionId);
+}
+export async function runAgent(options) {
+    // Backends the user switched off in the settings refuse new runs, from chats and jobs alike.
+    const backend = backendFor(options.backend);
+    if ((await preferences()).disabledAgents.includes(backend.id))
+        throw new Error("Этот агент отключён в настройках Projector");
+    await backend.run(options);
+}

package/packages/server/modules/agent/replay.js

@@ -0,0 +1,84 @@
+/**
+ * Collects the turns of a past session in the shape live answers have: text, reasoning and tool
+ * calls in the order they happened, so a reopened chat reads like the one that was watched.
+ */
+export function createReplay(backend, sessionId) {
+    const turns = [];
+    let counter = 0;
+    let at;
+    const turnFor = (role) => {
+        const last = turns.at(-1);
+        if (last?.role === role)
+            return last;
+        const turn = {
+            id: `replay-${++counter}`,
+            role,
+            text: "",
+            tools: [],
+            ...(at ? { at } : {}),
+            ...(role === "assistant" ? { session: { backend, id: sessionId }, parts: [] } : {}),
+        };
+        turns.push(turn);
+        return turn;
+    };
+    return {
+        turnFor,
+        /** The time of the messages that follow; a turn they open is stamped with it. */
+        mark(time) {
+            at = time;
+        },
+        user(text) {
+            turnFor("user").text += text;
+        },
+        text(text) {
+            if (!text)
+                return;
+            const turn = turnFor("assistant");
+            const parts = (turn.parts ??= []);
+            const last = parts.at(-1);
+            // Like a live answer: text that follows a finished message starts a new paragraph.
+            if (last?.type === "text") {
+                const gap = turn.text && !turn.text.endsWith("\n") ? "\n\n" : "";
+                last.text += gap + text;
+                turn.text += gap + text;
+            }
+            else {
+                if (turn.text.trim() && !turn.text.endsWith("\n\n"))
+                    turn.text += "\n\n";
+                parts.push({ type: "text", text });
+                turn.text += text;
+            }
+        },
+        thought(text) {
+            const parts = (turnFor("assistant").parts ??= []);
+            const last = parts.at(-1);
+            if (last?.type === "thought")
+                last.text += text;
+            else
+                parts.push({ type: "thought", text });
+        },
+        /** A line between messages that is not the agent's own words (the context was compacted). */
+        note(text) {
+            (turnFor("assistant").parts ??= []).push({ type: "note", text });
+        },
+        tool(tool) {
+            const turn = turnFor("assistant");
+            turn.tools.push(tool);
+            (turn.parts ??= []).push({ type: "tool", id: tool.id });
+        },
+        findTool(id) {
+            return turns.flatMap((turn) => turn.tools).find((item) => item.id === id);
+        },
+        /** Turns with something to show; empty chunks the agent sends between messages are dropped. */
+        get turns() {
+            return turns.filter((turn) => turn.text.trim() ||
+                turn.tools.length ||
+                turn.tasks?.length ||
+                turn.parts?.some((part) => part.type === "note" || part.type === "thought"));
+        },
+        /** Every task of the session, to update from a later report. */
+        get allTurns() {
+            return turns;
+        },
+    };
+}