copilot-operator 0.1.0

package/dist/src/api/operator.service.js

@@ -0,0 +1,1971 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/**
+ * Everything the web UI can do, in one service.
+ *
+ * The runner itself does not know it is being driven from a browser. This service supplies
+ * the three things that differ from the terminal: where approvals come from (a pending list
+ * the UI resolves), where events go (the bus, streamed as SSE), and how a run is stopped
+ * (an AbortController per session).
+ */
+import { Injectable } from '@nestjs/common';
+import { readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { installLayout } from '../config/layout.js';
+import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW } from '../session/store.js';
+import { EventBus } from '../session/events.js';
+import { newId, tidyVcsPlan } from '../session/model.js';
+import { runSession, openBrowser } from '../orchestrator/taskRunner.js';
+import { buildExport } from '../session/exportRecord.js';
+import { buildDebugExport } from '../session/debugExport.js';
+import { buildPlanExport, buildDomainExport, buildBotExport, buildBundleExport, exportFileName } from '../session/exports.js';
+import { suggestRunName } from '../session/runName.js';
+import { mirrorAllProjects, removeProjectMirrors, contextRoot } from '../context/desktopMirror.js';
+import { describeMirror } from '../context/projectMirror.js';
+import { buildStory } from '../session/story.js';
+import { checkPlan } from '../plan/schema.js';
+import { planBrief } from '../plan/brief.js';
+/** Windows paths: case and the slash direction do not make two folders. */
+function sameFolder(a, b) {
+    const norm = (p) => p.trim().replace(/[\\/]+$/, '').replace(/\//g, '\\').toLowerCase();
+    return a.trim() !== '' && norm(a) === norm(b);
+}
+import { importPlan, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
+import { vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
+import { gitAvailable, repoUnusableReason } from '../vcs/git.js';
+import { makeAuthorizer } from '../exec/authorizer.js';
+import { listSelectableDirs, collectFiles, findSelectionConflicts, describeConflicts, DEFAULT_IGNORE_DIRS } from '../context/projectMirror.js';
+import { pickFolder } from './folderPicker.js';
+import { findEdgeUsingProfile } from '../transport/profileLock.js';
+import { assessIsolation, readIsolationSignals, unattendedIsolationRefusal } from '../exec/isolation.js';
+import { unattendedPrecondition } from '../exec/policy.js';
+import { CopilotTransport } from '../transport/copilotTransport.js';
+import { resolveDesktopDir, desktopIsSynced } from '../context/contextFiles.js';
+import { saveAndReveal } from './saveToDesktop.js';
+import { Settings } from './settings.js';
+let OperatorService = class OperatorService {
+    /** Where this install keeps its prompts and its records. See `config/layout.ts`. */
+    layout = installLayout();
+    projectRoot = this.layout.projectRoot;
+    dataDir = this.layout.dataDir;
+    settings = new Settings(this.projectRoot, this.dataDir, this.layout.mode === 'package' ? { runsDir: this.layout.runsDir, level1File: join(this.layout.promptsDir, 'level1.md') } : {});
+    store = new SessionStore(this.dataDir, join(this.layout.promptsDir, 'level1.md'));
+    bus = new EventBus();
+    running = new Map();
+    waiting = new Map();
+    /** The batch in progress, or the last one that finished. At most one ever exists. */
+    batch = null;
+    ready = null;
+    /** One model read at a time: it launches a browser and holds the profile lock. */
+    readingModels = false;
+    /**
+     * One-time startup work, run lazily on the first request that needs the store.
+     *
+     * The recovery pass is part of it on purpose: no request should ever see a task still
+     * claiming to wait for an approval that died with the previous process.
+     */
+    init() {
+        this.ready ??= (async () => {
+            await this.store.init();
+            const recovered = await this.store.recoverInterrupted();
+            for (const r of recovered) {
+                this.bus.publish({
+                    sessionId: r.sessionId,
+                    taskId: r.taskId,
+                    type: 'task-recovered',
+                    level: 'warn',
+                    message: `"${r.title}" was left unfinished by an earlier run and has been marked aborted`,
+                });
+            }
+            if (recovered.length > 0) {
+                console.log(`[api] closed ${recovered.length} task(s) left unfinished by an earlier run`);
+            }
+        })();
+        return this.ready;
+    }
+    /** Runs the startup work now, so it does not wait for the first request. */
+    bootstrap() {
+        return this.init();
+    }
+    // --- level 1 --------------------------------------------------------------------------
+    async getLevel1() {
+        await this.init();
+        return await this.store.getLevel1();
+    }
+    async setLevel1(content) {
+        await this.init();
+        await this.store.setLevel1(content);
+    }
+    async resetLevel1() {
+        await this.init();
+        await this.store.resetLevel1();
+        return await this.store.getLevel1();
+    }
+    // --- the organisation's part of the plan persona -------------------------------------
+    async getContext(kind, lang) {
+        await this.init();
+        return await this.store.getContext(kind, lang === 'bg' ? 'bg' : 'en');
+    }
+    async setContext(kind, content) {
+        await this.init();
+        await this.store.setContext(kind, content);
+    }
+    async resetContext(kind, lang) {
+        await this.init();
+        await this.store.resetContext(kind);
+        return await this.store.getContext(kind, lang === 'bg' ? 'bg' : 'en');
+    }
+    // --- level 2 presets ------------------------------------------------------------------
+    async listPresets() {
+        await this.init();
+        return await this.store.listPresets();
+    }
+    async savePreset(name, content) {
+        await this.init();
+        return await this.store.savePreset(name, content);
+    }
+    async deletePreset(name) {
+        await this.init();
+        await this.store.deletePreset(name);
+    }
+    // --- sessions and tasks ---------------------------------------------------------------
+    async listSessions() {
+        await this.init();
+        const all = await this.store.listSessions();
+        return all.map((s) => ({ ...s, running: this.running.has(s.id) }));
+    }
+    async getSession(id) {
+        await this.init();
+        const s = await this.store.getSession(id);
+        if (!s)
+            return null;
+        const pending = [...this.waiting.values()].filter((w) => w.approval.sessionId === id).map((w) => w.approval);
+        return { ...s, running: this.running.has(id), pending, runMode: this.running.get(id)?.mode };
+    }
+    async createSession(name, mirror) {
+        await this.init();
+        if (mirror)
+            assertMirrorIsCoherent(mirror);
+        const session = await this.store.createSession(name, mirror);
+        // A new session starts on the standing choice, if there is one. It is copied onto the
+        // session rather than read at run time, so changing the default later cannot silently
+        // change what an existing session does.
+        const cfg = await this.settings.load();
+        const defaultModel = (cfg.copilot.defaultModel ?? '').trim();
+        const defaultReviewModel = (cfg.copilot.defaultReviewModel ?? '').trim();
+        const projectDir = (cfg.project?.rootDir ?? '').trim();
+        if (!defaultModel && !defaultReviewModel && !projectDir)
+            return session;
+        return await this.store.updateSession(session.id, (s) => {
+            if (defaultModel)
+                s.model = defaultModel;
+            if (defaultReviewModel)
+                s.review = { enabled: s.review?.enabled !== false, model: defaultReviewModel };
+            if (projectDir) {
+                // Both fields, because they answer different questions about the same folder: where the
+                // files are and where the branches go. Neither is switched on by being filled in.
+                if (!s.mirror.rootDir.trim())
+                    s.mirror.rootDir = projectDir;
+                if (s.vcs && !s.vcs.repoDir.trim())
+                    s.vcs.repoDir = projectDir;
+            }
+        });
+    }
+    async updateSession(id, patch) {
+        await this.init();
+        return await this.store.updateSession(id, (s) => {
+            if (patch.name !== undefined)
+                s.name = patch.name.trim() || s.name;
+            if (patch.onFailure === 'stop' || patch.onFailure === 'continue')
+                s.onFailure = patch.onFailure;
+            // An empty string is a real choice here: it means "leave the chat on whatever it is".
+            if (patch.model !== undefined)
+                s.model = patch.model.trim() || undefined;
+            // The same for the group: clearing it gives this session its conversation back. It does
+            // not move the conversation it is already in; that history is where it is.
+            if (patch.conversationGroup !== undefined)
+                s.conversationGroup = patch.conversationGroup.trim() || undefined;
+            if (patch.review) {
+                // Empty model means "the session's own", which is a real choice and not a missing one.
+                const merged = { ...DEFAULT_REVIEW, ...s.review, ...patch.review };
+                s.review = { enabled: merged.enabled !== false, model: (merged.model ?? '').trim() };
+            }
+            if (patch.mirror) {
+                const merged = { ...s.mirror, ...patch.mirror };
+                assertMirrorIsCoherent(merged);
+                s.mirror = merged;
+            }
+            if (patch.vcs) {
+                const merged = { ...DEFAULT_VCS, ...s.vcs, ...patch.vcs };
+                // A prefix is what makes the bot's branches recognisable in `git branch`, so an empty
+                // one is treated as "I did not mean to change this" rather than as a choice.
+                merged.branchPrefix = merged.branchPrefix.trim() || DEFAULT_VCS.branchPrefix;
+                merged.repoDir = merged.repoDir.trim();
+                if (merged.enabled) {
+                    const reason = repoUnusableReason(merged.repoDir || s.mirror.rootDir || '');
+                    if (reason)
+                        throw new Error(reason);
+                }
+                s.vcs = merged;
+            }
+        });
+    }
+    async deleteSession(id) {
+        await this.init();
+        if (this.running.has(id))
+            throw new Error('Stop the session before deleting it.');
+        await this.store.deleteSession(id);
+    }
+    async addTask(sessionId, input) {
+        await this.init();
+        if (!input.prompt?.trim())
+            throw new Error('A task needs a prompt.');
+        return await this.store.addTask(sessionId, input);
+    }
+    /**
+     * Edits a queued task, including the names it carries into git.
+     *
+     * Everything an imported plan can set, the form can change: a task that arrived as JSON is
+     * the same object as one typed in by hand, and the moment the two diverge is the moment an
+     * import becomes a thing you cannot correct without editing a file.
+     */
+    async updateTask(sessionId, taskId, patch) {
+        await this.init();
+        return await this.store.updateTask(sessionId, taskId, (t) => {
+            if (t.status !== 'queued')
+                throw new Error('Only a queued task can be edited.');
+            if (patch.title !== undefined)
+                t.title = patch.title;
+            if (patch.level2 !== undefined)
+                t.level2 = patch.level2;
+            if (patch.prompt !== undefined)
+                t.prompt = patch.prompt;
+            if (patch.vcsPlan !== undefined)
+                t.vcsPlan = tidyVcsPlan(patch.vcsPlan);
+            if (patch.checks !== undefined)
+                t.checks = patch.checks.filter((c) => c.name.trim() !== '');
+        });
+    }
+    async deleteTask(sessionId, taskId) {
+        await this.init();
+        await this.store.deleteTask(sessionId, taskId);
+    }
+    /**
+     * Puts a finished task back in the queue, keeping the record of what it already did.
+     *
+     * An optional patch is how a finished task is edited: the attempt that ran is archived with
+     * the text it ran with, and only then is the new text applied. Editing in place would leave
+     * the old attempt's summary sitting under a question that was never asked.
+     */
+    async rerunTask(sessionId, taskId, patch = {}) {
+        await this.init();
+        const task = await this.store.rerunTask(sessionId, taskId, patch);
+        this.bus.publish({
+            sessionId,
+            taskId,
+            type: 'task-requeued',
+            level: 'info',
+            message: `"${task.title}" is queued again (attempt ${task.attempt ?? 1})`,
+            data: { attempt: task.attempt },
+        });
+        return task;
+    }
+    /**
+     * The consolidated text log of a task, or null when it has not produced one.
+     *
+     * `runId` asks for one particular attempt. It is checked against the run ids this task
+     * actually owns, so the parameter cannot be used to read another task's folder, or any
+     * other folder on the machine.
+     */
+    async taskLog(sessionId, taskId, runId) {
+        const cfg = await this.settings.load();
+        const s = await this.store.getSession(sessionId);
+        const t = s?.tasks.find((x) => x.id === taskId);
+        const chosen = resolveRunId(t, runId);
+        if (!chosen)
+            return null;
+        const path = join(cfg.resolved.runsDir, chosen, 'task-log.txt');
+        return existsSync(path) ? await readFile(path, 'utf8') : null;
+    }
+    /**
+     * The story of one attempt, assembled from its run folder: what was sent, what the chat
+     * answered, what ran with its output, the review rounds, how it ended. Read while it runs
+     * (the page polls) and afterwards; `runId` picks an earlier attempt.
+     */
+    async taskStory(sessionId, taskId, runId) {
+        const cfg = await this.settings.load();
+        const s = await this.store.getSession(sessionId);
+        const t = s?.tasks.find((x) => x.id === taskId);
+        const chosen = resolveRunId(t, runId);
+        if (!t || !chosen)
+            return null;
+        const current = chosen === t.runId;
+        // An earlier attempt is read with its own record, so the closing summary is that attempt's.
+        const attempt = current ? t : (t.attempts ?? []).find((a) => a.runId === chosen);
+        const view = current || !attempt ? t : { ...t, ...attempt, status: attempt.status, attempts: undefined };
+        const live = current && this.running.has(sessionId) && (t.status === 'running' || t.status === 'waiting-approval');
+        return await buildStory(cfg.resolved.runsDir, chosen, view, live);
+    }
+    /** Files a task produced, so the UI can list reports and downloaded scripts. */
+    async taskFiles(sessionId, taskId, runId) {
+        const cfg = await this.settings.load();
+        const s = await this.store.getSession(sessionId);
+        const t = s?.tasks.find((x) => x.id === taskId);
+        const empty = { reports: [], artifacts: [], replies: [] };
+        const chosen = resolveRunId(t, runId);
+        if (!chosen)
+            return empty;
+        const base = join(cfg.resolved.runsDir, chosen);
+        const ls = async (sub) => (await readdir(join(base, sub)).catch(() => [])).filter((n) => !n.startsWith('_')).sort();
+        return { reports: await ls('reports'), artifacts: await ls('artifacts'), replies: await ls('replies') };
+    }
+    async taskFile(sessionId, taskId, kind, name, runId) {
+        if (name.includes('..') || name.includes('/') || name.includes('\\'))
+            return null;
+        const cfg = await this.settings.load();
+        const s = await this.store.getSession(sessionId);
+        const t = s?.tasks.find((x) => x.id === taskId);
+        const chosen = resolveRunId(t, runId);
+        if (!chosen)
+            return null;
+        const path = join(cfg.resolved.runsDir, chosen, kind, name);
+        return existsSync(path) ? await readFile(path, 'utf8') : null;
+    }
+    /**
+     * The same log, written to the Desktop and shown in Explorer instead of to the browser.
+     *
+     * What the operator does with a log is hand it to the chat that orchestrates the effort, so
+     * the useful end of the journey is a file under the cursor, not a page in a tab. The reading
+     * is delegated to `taskLog` rather than repeated here: that method already decides which run
+     * folder this task is allowed to open, and a second copy of that decision is a second place
+     * for it to be got wrong.
+     */
+    async saveTaskLog(sessionId, taskId, runId) {
+        const text = await this.taskLog(sessionId, taskId, runId);
+        if (text === null)
+            return null;
+        return await saveAndReveal(text, await this.namingFor(sessionId, taskId, runId));
+    }
+    /** One of a task's own files, saved and revealed the same way. They are logs by another name. */
+    async saveTaskFile(sessionId, taskId, kind, name, runId) {
+        const text = await this.taskFile(sessionId, taskId, kind, name, runId);
+        if (text === null)
+            return null;
+        return await saveAndReveal(text, { ...(await this.namingFor(sessionId, taskId, runId)), file: name });
+    }
+    /**
+     * What a saved file is named after.
+     *
+     * An earlier attempt is named from its own snapshot rather than from the task as it stands
+     * now: a task can be edited between attempts, and a file called after today's title would
+     * claim the old log answered a question it was never asked.
+     */
+    async namingFor(sessionId, taskId, runId) {
+        const s = await this.store.getSession(sessionId);
+        const t = s?.tasks.find((x) => x.id === taskId);
+        const chosen = resolveRunId(t, runId);
+        const earlier = chosen && t && chosen !== t.runId ? (t.attempts ?? []).findIndex((a) => a.runId === chosen) : -1;
+        const attempt = earlier >= 0 ? earlier + 1 : (t?.attempt ?? 1);
+        return {
+            session: s?.name ?? sessionId,
+            task: (earlier >= 0 ? t?.attempts?.[earlier]?.title : t?.title) ?? taskId,
+            // A task that has only ever run once has nothing to be told apart from.
+            attempt: attempt > 1 ? attempt : undefined,
+        };
+    }
+    /**
+     * The record of selected tasks as one downloadable document.
+     *
+     * `taskIds` empty means every task of the session that has actually run. A queued task has
+     * nothing to say yet, and silently including it would put an empty section in a document
+     * someone is about to send to a colleague.
+     */
+    async exportTasks(sessionId, taskIds, variant) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const wanted = taskIds.length > 0 ? session.tasks.filter((t) => taskIds.includes(t.id)) : session.tasks;
+        const tasks = wanted.filter((t) => t.status !== 'queued');
+        if (tasks.length === 0) {
+            throw new Error('None of the selected tasks has run yet, so there is nothing to export.');
+        }
+        const cfg = await this.settings.load();
+        return await buildExport({ session, tasks, variant, runsDir: cfg.resolved.runsDir });
+    }
+    /**
+     * Everything that happened across a set of sessions, as one JSON document.
+     *
+     * Given no ids it exports the sessions of the last batch, because the commonest moment for
+     * wanting this is right after a run of several went wrong and the operator wants to hand the
+     * whole thing to somebody who was not watching.
+     */
+    async debugExport(sessionIds) {
+        await this.init();
+        const wanted = sessionIds.map((x) => x.trim()).filter(Boolean);
+        const ids = wanted.length > 0 ? wanted : (this.batch?.sessions ?? []).map((s) => s.sessionId);
+        if (ids.length === 0) {
+            throw new Error('No sessions were named, and no batch has run in this process to fall back on.');
+        }
+        const sessions = [];
+        for (const id of ids) {
+            const session = await this.store.getSession(id);
+            if (session)
+                sessions.push(session);
+        }
+        if (sessions.length === 0)
+            throw new Error('None of those sessions exists any more.');
+        const cfg = await this.settings.load();
+        return await buildDebugExport({ sessions, runsDir: cfg.resolved.runsDir, cwd: cfg.resolved.cwd });
+    }
+    /**
+     * One of the three JSON views (plan, domain, bot) of one task, one session or one run.
+     *
+     * A run is everything that one press of a start button set off, across sessions: the tasks
+     * stamped with its id, and the sessions that were part of it even where a task never got its
+     * turn. The file is named after the run's own name when it has one, because a file called
+     * `run-r-abc123` is not something anyone can find again.
+     */
+    async exportView(kind, where) {
+        await this.init();
+        let scope;
+        if (where.runId) {
+            const runId = where.runId;
+            const all = await this.store.listSessions();
+            const sessions = all
+                .filter((s) => s.runGroup?.id === runId || s.tasks.some((t) => t.runGroup?.id === runId || t.attempts?.some((a) => a.runGroup?.id === runId)))
+                .sort((a, b) => (a.runGroup?.id === runId ? (a.runGroup.order ?? 0) : 0) - (b.runGroup?.id === runId ? (b.runGroup.order ?? 0) : 0));
+            if (sessions.length === 0)
+                throw new Error(`No session took part in run ${runId}.`);
+            const group = sessions.map((s) => s.runGroup).find((g) => g?.id === runId);
+            const name = group?.name?.trim() || `run-${(group?.startedAt ?? '').slice(0, 16).replace(/[:T]/g, '-')}`;
+            scope = {
+                sessions,
+                // A task belongs to the run if this attempt ran in it, or if it was queued for it and
+                // never reached — that second kind is what the run's own record on the session is for.
+                taskFilter: (s, t) => t.runGroup?.id === runId || (s.runGroup?.id === runId && s.runGroup.taskIds.includes(t.id)),
+                label: name,
+            };
+        }
+        else if (where.sessionId) {
+            const session = await this.store.getSession(where.sessionId);
+            if (!session)
+                throw new Error('No such session.');
+            if (where.taskId) {
+                const task = session.tasks.find((t) => t.id === where.taskId);
+                if (!task)
+                    throw new Error('No such task.');
+                scope = { sessions: [session], taskFilter: (_s, t) => t.id === task.id, label: `${session.name}-${task.title}` };
+            }
+            else {
+                scope = { sessions: [session], label: session.name };
+            }
+        }
+        else {
+            throw new Error('Name a run, a session or a task.');
+        }
+        const cfg = await this.settings.load();
+        const document = kind === 'plan'
+            ? buildPlanExport(scope)
+            : kind === 'domain'
+                ? await buildDomainExport(scope, cfg.resolved.runsDir)
+                : await buildBotExport(scope, cfg.resolved.runsDir, {
+                    node: process.versions.node,
+                    platform: process.platform,
+                    cwd: cfg.resolved.cwd,
+                    limits: { ...cfg.limits, execution: { commandTimeoutSec: cfg.execution.commandTimeoutSec, idleTimeoutSec: cfg.execution.idleTimeoutSec, mode: cfg.execution.mode } },
+                });
+        return { fileName: exportFileName(kind, scope.label), content: JSON.stringify(document, null, 2) };
+    }
+    /**
+     * All three views of a set of tasks the operator picked by hand, in one file.
+     *
+     * The pairs carry their session because a selection spans runs and sessions — that is the
+     * point of it — so a task id on its own would not say which session's task it is. Unknown
+     * pairs are dropped rather than refused: a register left open while a session is deleted
+     * elsewhere should still hand over the tasks that are still there, and the document says
+     * which ones it holds.
+     */
+    async exportBundle(pairs) {
+        await this.init();
+        if (pairs.length === 0)
+            throw new Error('Choose at least one task.');
+        const wanted = new Map();
+        for (const { sessionId, taskId } of pairs) {
+            const set = wanted.get(sessionId) ?? new Set();
+            set.add(taskId);
+            wanted.set(sessionId, set);
+        }
+        const sessions = [];
+        for (const sessionId of wanted.keys()) {
+            const session = await this.store.getSession(sessionId);
+            if (session)
+                sessions.push(session);
+        }
+        const found = sessions.flatMap((s) => s.tasks.filter((t) => wanted.get(s.id)?.has(t.id)));
+        if (found.length === 0)
+            throw new Error('None of the chosen tasks still exists.');
+        // Named after what was chosen rather than after a run, because a selection is not a run: it
+        // may be one task of one, or a task from each of three.
+        const label = found.length === 1 && sessions.length === 1
+            ? `${sessions[0].name}-${found[0].title}`
+            : sessions.length === 1
+                ? `${sessions[0].name}-${found.length}-tasks`
+                : `${found.length}-tasks-${sessions.length}-sessions`;
+        const cfg = await this.settings.load();
+        const document = await buildBundleExport({ sessions, taskFilter: (s, t) => !!wanted.get(s.id)?.has(t.id), label }, cfg.resolved.runsDir, {
+            node: process.versions.node,
+            platform: process.platform,
+            cwd: cfg.resolved.cwd,
+            limits: { ...cfg.limits, execution: { commandTimeoutSec: cfg.execution.commandTimeoutSec, idleTimeoutSec: cfg.execution.idleTimeoutSec, mode: cfg.execution.mode } },
+        });
+        return { fileName: exportFileName('bundle', label), content: JSON.stringify(document, null, 2) };
+    }
+    // --- running --------------------------------------------------------------------------
+    isRunning(sessionId) {
+        return this.running.has(sessionId);
+    }
+    /**
+     * Starts the session's queued tasks in the background. Returns immediately; progress
+     * arrives on the event stream. One run per session at a time.
+     */
+    async start(sessionId, mode = 'confirm', name) {
+        // One conversation at a time is not a policy, it is the browser profile: a second run
+        // does not get a second browser, it gets an error about a closed one. A batch already
+        // holds that turn, so a single session asking for it now is refused where the reason can
+        // still be read, rather than three minutes later in a stack trace.
+        if (this.batch?.running)
+            return { started: false, reason: 'a batch of sessions is running' };
+        // A run nobody named is named after what it is a run of, rather than left to show up in the
+        // register as "Unnamed run" beside five others of the same description.
+        const chosenName = name?.trim() || (await this.suggestRunName([sessionId]));
+        const runGroup = { id: newId('r-'), startedAt: new Date().toISOString(), sessions: 1, name: chosenName };
+        // A run of one is still a run, and it records the same thing a batch does, so that going
+        // back and starting again from a task works the same whether one session was started or six.
+        await this.store.updateSession(sessionId, (s) => {
+            s.runGroup = {
+                ...runGroup,
+                order: 0,
+                taskIds: s.tasks.filter((t) => t.status === 'queued').map((t) => t.id),
+                mode,
+                onFailure: s.onFailure === 'continue' ? 'continue' : 'stop',
+            };
+        });
+        const begun = await this.beginRun(sessionId, mode, undefined, runGroup);
+        return { started: begun.started, reason: begun.reason };
+    }
+    /**
+     * The same thing `start` does, but it also hands back a promise that settles when the run
+     * is over and says how it went.
+     *
+     * A batch needs that promise and a single session does not, which is the only difference
+     * between the two callers. The sessions of a batch still run one at a time through here,
+     * and they have to: the browser profile is single-writer, so two conversations at once is
+     * not slower, it is a failure with a message about a closed browser.
+     */
+    async beginRun(sessionId, mode, 
+    /** A browser that is already open. A batch passes its own; a single run opens one. */
+    transport, 
+    /** The press of a start button this belongs to, stamped onto every task it reaches. */
+    runGroup) {
+        await this.init();
+        // Every project's Desktop copy brought up to date before the chat opens, when the operator
+        // asked for that. Before the run rather than before each task: a task's own mirror already
+        // refreshes its project, and the other projects do not change while the bot works.
+        await this.refreshDesktopMirrors();
+        const idle = { ran: 0, failed: 0, leftQueued: 0, failedTitles: [] };
+        if (this.running.has(sessionId))
+            return { started: false, reason: 'already running', done: Promise.resolve(idle) };
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            return { started: false, reason: 'no such session', done: Promise.resolve(idle) };
+        const queuedIds = session.tasks.filter((t) => t.status === 'queued').map((t) => t.id);
+        if (queuedIds.length === 0)
+            return { started: false, reason: 'no queued tasks', done: Promise.resolve(idle) };
+        const cfg = await this.settings.load();
+        const policy = {
+            mode,
+            denyPatterns: cfg.execution.denyPatterns,
+            allowedPrograms: cfg.execution.allowedPrograms,
+            isolation: cfg.execution.isolation,
+            lockedToConfirm: cfg.policyLock?.maxMode === 'confirm',
+        };
+        /*
+         * An unattended run that cannot legally execute anything is stopped here, where the operator
+         * is looking, rather than starting and returning every step refused. The step gate holds the
+         * same rule and is what actually enforces it; this is so the answer arrives once, before a
+         * browser is opened and a conversation is started, and names the setting to change.
+         */
+        const precondition = unattendedPrecondition(policy);
+        if (precondition)
+            return { started: false, reason: precondition, done: Promise.resolve(idle) };
+        const controller = new AbortController();
+        /*
+         * The same authorizer in both modes. It used to be `unattendedAuthorizer` here for an unattended
+         * run, which has no way to ask anybody; but a step that fetches from the network is put to the
+         * operator whatever the mode (see `network.ts`), and the approval screen is where that happens.
+         * `makeAuthorizer` reads `policy.mode` on every step, so an unattended run still asks about
+         * nothing else.
+         */
+        const authorizer = this.webAuthorizer(policy, controller.signal);
+        this.running.set(sessionId, { controller, startedAt: new Date().toISOString(), mode, policy });
+        this.bus.publish({ sessionId, type: 'run-requested', level: 'info', message: `starting in ${mode} mode` });
+        // Said at the start of every run, in both modes, because it is the one fact about this tool a
+        // data-protection team needs and the one an operator forgets: the reports leave the machine.
+        this.bus.publish({
+            sessionId,
+            type: 'upload-notice',
+            level: 'info',
+            message: "every report of this run — each step's terminal output, the check results, the reviewer's transcripts — and any " +
+                "mirrored project files are uploaded into the Copilot chat and stored in the signed-in account's OneDrive and " +
+                'Copilot history, inside the tenant; secret-shaped strings are redacted first',
+        });
+        const done = runSession(sessionId, {
+            cfg: { ...cfg, execution: { ...cfg.execution, mode } },
+            store: this.store,
+            bus: this.bus,
+            authorizer,
+            signal: controller.signal,
+            // Read between tasks, so the one in flight finishes properly first. The batch owns the
+            // flag, because a pause is about the whole run and not about this session.
+            shouldPause: () => !!this.batch?.pausing,
+            // The mode as it is now, not as it was: "run the rest without asking" changes it mid-run,
+            // and the policy.json of a later task must say so.
+            currentMode: () => this.running.get(sessionId)?.mode ?? mode,
+            // The session decides whether its tasks are one chain or a set of independent checks.
+            continueOnFailure: session.onFailure === 'continue',
+            transport,
+            runGroup,
+        })
+            .then(async (outcome) => ({ ...(await this.tally(sessionId, queuedIds)), paused: outcome.paused }))
+            .catch(async (e) => {
+            this.bus.publish({ sessionId, type: 'run-failed', level: 'error', message: e.message });
+            return { ...(await this.tally(sessionId, queuedIds)), error: e.message };
+        })
+            .finally(() => {
+            this.running.delete(sessionId);
+            for (const [id, w] of this.waiting) {
+                if (w.approval.sessionId === sessionId) {
+                    w.resolve({ action: 'abort', reason: 'the run ended' });
+                    this.waiting.delete(id);
+                }
+            }
+        });
+        return { started: true, done };
+    }
+    /**
+     * How a finished run went, read from the tasks it was given rather than from its return
+     * value.
+     *
+     * Only the tasks that were queued when the run began are counted, so a session that already
+     * held a failure from last week does not make today's run look failed.
+     */
+    async tally(sessionId, taskIds) {
+        const session = await this.store.getSession(sessionId);
+        const tally = { ran: 0, failed: 0, leftQueued: 0, failedTitles: [] };
+        for (const id of taskIds) {
+            const task = session?.tasks.find((t) => t.id === id);
+            if (!task)
+                continue;
+            if (task.status === 'queued') {
+                tally.leftQueued += 1;
+                continue;
+            }
+            tally.ran += 1;
+            if (task.status !== 'done') {
+                tally.failed += 1;
+                tally.failedTitles.push(task.title);
+            }
+        }
+        return tally;
+    }
+    /** Asks the run to stop after the current step. Pending approvals are aborted at once. */
+    async stop(sessionId) {
+        const r = this.running.get(sessionId);
+        if (!r)
+            return { stopping: false };
+        r.controller.abort();
+        for (const [id, w] of this.waiting) {
+            if (w.approval.sessionId === sessionId) {
+                w.resolve({ action: 'abort', reason: 'stopped by the operator' });
+                this.waiting.delete(id);
+            }
+        }
+        await this.store.updateSession(sessionId, (s) => {
+            s.status = 'stopping';
+        });
+        this.bus.publish({ sessionId, type: 'stop-requested', level: 'warn', message: 'stopping after the current step' });
+        return { stopping: true };
+    }
+    // --- running several sessions in turn -------------------------------------------------
+    /**
+     * Whether the bot is working right now, and nothing else.
+     *
+     * Every page asks this on a timer so the register's own button can say `live`, which is the
+     * only reason it is separate from the registry: the registry reads every session off disk to
+     * answer a question this one answers from two fields already in memory. A poll that costs a
+     * directory walk every few seconds, on every page, to light up a dot would be a bad trade.
+     */
+    activity() {
+        return { running: this.running.size > 0, sessions: this.running.size, batch: this.batch?.running === true };
+    }
+    /** The batch in progress, or the last one that ran, or null if none ever has. */
+    batchState() {
+        return this.batch ? { ...this.batch, sessions: this.batch.sessions.map((s) => ({ ...s })) } : null;
+    }
+    /**
+     * Runs the queued tasks of several sessions, one session after another.
+     *
+     * The order is the order the ids arrive in, which is the order the operator ticked them.
+     * `onFailure` is the same question the task queue already asks, one level up: `stop` treats
+     * the sessions as a chain, `continue` treats them as separate pieces of work that happen to
+     * have been started together.
+     */
+    /**
+     * What to call a run nobody named. The rule and the reasoning are in `session/runName.ts`;
+     * this only fetches the sessions it needs to answer over.
+     */
+    async suggestRunName(sessionIds, about) {
+        return suggestRunName(await this.store.listSessions(), sessionIds, about);
+    }
+    async startBatch(sessionIds, mode = 'confirm', onFailure = 'stop', model, 
+    /**
+     * The model the independent review runs on, for every session in this run.
+     *
+     * Separate from `model` because they are separate decisions, and the interesting case is
+     * precisely when they differ: a review is worth most when it is not the same mind that did
+     * the work, and a run panel that could only set one model made that the hard path.
+     */
+    reviewModel, 
+    /** What to call the run. Offered from the plan's name; empty means it goes by its id. */
+    name) {
+        await this.init();
+        if (this.batch?.running)
+            return { started: false, reason: 'a batch is already running' };
+        const wanted = [...new Set(sessionIds.map((s) => s.trim()).filter(Boolean))];
+        if (wanted.length === 0)
+            return { started: false, reason: 'no sessions were selected' };
+        // Worked out here rather than asked of the operator again: every way into this — the run
+        // panel, continuing after a failure, "Run again from here" — either has a field they may
+        // have left empty or has no field at all.
+        const chosenName = name?.trim() || (await this.suggestRunName(wanted));
+        if (wanted.some((id) => this.running.has(id))) {
+            return { started: false, reason: 'one of the selected sessions is already running on its own' };
+        }
+        const sessions = [];
+        for (const id of wanted) {
+            const s = await this.store.getSession(id);
+            if (!s) {
+                sessions.push({ sessionId: id, name: id, state: 'skipped', ran: 0, failed: 0, reason: 'no such session' });
+                continue;
+            }
+            const queued = s.tasks.filter((t) => t.status === 'queued').length;
+            sessions.push(queued === 0
+                ? { sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: 'nothing queued' }
+                : { sessionId: id, name: s.name, state: 'waiting', ran: 0, failed: 0 });
+        }
+        if (!sessions.some((s) => s.state === 'waiting')) {
+            return { started: false, reason: 'none of the selected sessions has a queued task' };
+        }
+        /*
+         * The same entrance rule `start` has, asked here too and for the same reason: before a browser
+         * is opened. It was missing, and the rule was only met inside the loop, per session, after the
+         * window was already up — so on a machine with no isolation the operator pressed the run
+         * button, watched Edge open, begin loading the chat and close again, and was told nothing: the
+         * session was quietly skipped with the reason held in a batch state nobody was looking at. Asked
+         * here, the refusal is the answer to the press, shown under the button that caused it.
+         */
+        {
+            const cfg = await this.settings.load();
+            const blocked = unattendedPrecondition({
+                mode,
+                allowedPrograms: cfg.execution.allowedPrograms,
+                isolation: cfg.execution.isolation,
+                lockedToConfirm: cfg.policyLock?.maxMode === 'confirm',
+            });
+            if (blocked)
+                return { started: false, reason: blocked };
+        }
+        // One model for the whole run, chosen here rather than opened on every session first. It
+        // is written onto the sessions instead of being held for the run, so what the session says
+        // it will use and what it used are the same thing afterwards — including for anyone who
+        // opens one of them tomorrow and wonders which model produced that summary.
+        const wantedModel = model?.trim();
+        const wantedReviewModel = reviewModel?.trim();
+        if (wantedModel || wantedReviewModel) {
+            for (const entry of sessions) {
+                if (entry.state !== 'waiting')
+                    continue;
+                await this.store.updateSession(entry.sessionId, (s) => {
+                    if (wantedModel)
+                        s.model = wantedModel;
+                    // Only the model is set here, never whether the review happens: a run panel is about
+                    // this run, and silently switching a session's review on or off from it would be a
+                    // change to the session that outlives the run.
+                    if (wantedReviewModel)
+                        s.review = { ...DEFAULT_REVIEW, ...s.review, model: wantedReviewModel };
+                });
+            }
+        }
+        this.batch = {
+            id: newId('b-'),
+            startedAt: new Date().toISOString(),
+            name: chosenName,
+            mode,
+            onFailure,
+            stopping: false,
+            pausing: false,
+            running: true,
+            sessions,
+        };
+        void this.runBatch();
+        return { started: true, batch: this.batchState() };
+    }
+    /** Stops the session that is running now and leaves the rest of the batch unstarted. */
+    /**
+     * Holds the run after the task that is running, and lets that task finish first.
+     *
+     * Not a stop: the task in flight runs its checks, is reviewed and commits, exactly as it would
+     * have. What is held is the queue behind it, and the sessions after this one, both of which
+     * stay as they are — so continuing is the same act it always was, and the button for it is the
+     * one already on the register.
+     *
+     * It does not release the browser early either. The run ends when the current task does, and
+     * the window closes with it, because the Edge profile is single-writer and a run that sat
+     * holding it would stop every other session from doing anything at all.
+     */
+    async pauseBatch() {
+        const batch = this.batch;
+        if (!batch?.running || batch.stopping)
+            return { pausing: false };
+        batch.pausing = true;
+        this.bus.publish({
+            sessionId: batch.sessions.find((s) => s.state === 'running')?.sessionId ?? batch.id,
+            type: 'batch-pausing',
+            level: 'info',
+            message: 'pausing: the task that is running will finish, and the rest of the queue stays as it is',
+            data: { batchId: batch.id },
+        });
+        return { pausing: true };
+    }
+    /** Takes the hold off a run that has not ended yet, so the queue carries on where it was. */
+    async resumeBatch() {
+        const batch = this.batch;
+        if (!batch?.running || !batch.pausing)
+            return { pausing: false };
+        batch.pausing = false;
+        this.bus.publish({
+            sessionId: batch.sessions.find((s) => s.state === 'running')?.sessionId ?? batch.id,
+            type: 'batch-resumed',
+            level: 'info',
+            message: 'the hold is off; the queue carries on',
+            data: { batchId: batch.id },
+        });
+        return { pausing: false };
+    }
+    async stopBatch() {
+        const batch = this.batch;
+        if (!batch?.running)
+            return { stopping: false };
+        batch.stopping = true;
+        const current = batch.sessions.find((s) => s.state === 'running');
+        if (current)
+            await this.stop(current.sessionId);
+        return { stopping: true };
+    }
+    /**
+     * The batch loop. Nothing here runs in parallel, on purpose: see `beginRun`.
+     *
+     * Each session is judged by the tasks it was given. A session that ran everything without a
+     * failure is `done`; one with a failed task is `failed`; one the operator stopped, or one
+     * whose chain stopped early with no failure of its own, is `stopped`.
+     */
+    async runBatch() {
+        const batch = this.batch;
+        if (!batch)
+            return;
+        /*
+         * One browser for the whole batch.
+         *
+         * Every session used to open its own window and close it again: a fresh launch, a fresh
+         * sign-in check and a fresh grab at the profile lock, several times over, for a machine
+         * that can only have one of them open at a time anyway. The window is opened here, handed
+         * to each session in turn, and closed when the last one is done — so between sessions the
+         * only thing that changes is which conversation is on screen.
+         */
+        let browser = null;
+        try {
+            const cfg = await this.settings.load();
+            browser = await openBrowser(cfg, this.bus, join(cfg.resolved.runsDir, '_browser'), batch.id);
+            this.bus.publish({
+                sessionId: batch.sessions[0]?.sessionId ?? batch.id,
+                type: 'batch-browser-open',
+                level: 'info',
+                message: `one browser window for all ${batch.sessions.length} session(s) in this run`,
+                data: { batchId: batch.id },
+            });
+        }
+        catch (e) {
+            // Without a window nothing can run, and saying so once is better than failing every
+            // session in turn with the same message.
+            for (const entry of batch.sessions) {
+                if (entry.state === 'waiting') {
+                    entry.state = 'failed';
+                    entry.reason = `the browser could not be opened: ${e.message}`;
+                }
+            }
+            batch.running = false;
+            batch.finishedAt = new Date().toISOString();
+            this.bus.publish({
+                sessionId: batch.id,
+                type: 'batch-error',
+                level: 'error',
+                message: `the browser could not be opened: ${e.message}`,
+            });
+            return;
+        }
+        try {
+            /*
+             * One group for the whole batch, made before the loop rather than per session.
+             *
+             * That is the entire point of it: the register can then draw one line around everything
+             * this press of the button set off, across sessions, which is the question a list of
+             * tasks sorted by time cannot answer.
+             */
+            const runGroup = {
+                id: batch.id,
+                startedAt: batch.startedAt,
+                sessions: batch.sessions.filter((s) => s.state === 'waiting').length,
+                ...(batch.name ? { name: batch.name } : {}),
+            };
+            /*
+             * The same run, recorded on each session, with what it was asked to do.
+             *
+             * Written before the first session starts and for every session including the ones the
+             * run may never reach, because that is precisely the case it exists for: a failure in
+             * session one leaves sessions two and three with no tasks stamped and no way to know
+             * they were ever part of this. Going back afterwards and running the rest again needs
+             * the whole list, and this is the only place it is still true.
+             */
+            let order = 0;
+            for (const entry of batch.sessions) {
+                if (entry.state !== 'waiting')
+                    continue;
+                const at = order;
+                order += 1;
+                await this.store.updateSession(entry.sessionId, (s) => {
+                    s.runGroup = {
+                        ...runGroup,
+                        order: at,
+                        taskIds: s.tasks.filter((t) => t.status === 'queued').map((t) => t.id),
+                        mode: batch.mode,
+                        onFailure: batch.onFailure,
+                    };
+                });
+            }
+            for (const entry of batch.sessions) {
+                if (entry.state !== 'waiting')
+                    continue;
+                if (batch.stopping) {
+                    entry.state = 'skipped';
+                    entry.reason = 'the batch was stopped before this session started';
+                    continue;
+                }
+                // A hold applies to the sessions that have not started as well as to the queue inside
+                // the one that has. They are left exactly as they were, which is what makes continuing
+                // afterwards the same act as continuing after anything else.
+                if (batch.pausing) {
+                    entry.state = 'skipped';
+                    entry.reason = 'the run was paused before this session started; its tasks are still queued';
+                    continue;
+                }
+                entry.state = 'running';
+                this.bus.publish({
+                    sessionId: entry.sessionId,
+                    type: 'batch-session-started',
+                    level: 'info',
+                    message: `starting as part of a batch of ${batch.sessions.length} session(s), in ${batch.mode} mode`,
+                    data: { batchId: batch.id },
+                });
+                const begun = await this.beginRun(entry.sessionId, batch.mode, browser, runGroup);
+                if (!begun.started) {
+                    entry.state = 'skipped';
+                    entry.reason = begun.reason;
+                    continue;
+                }
+                const tally = await begun.done;
+                entry.ran = tally.ran;
+                entry.failed = tally.failed;
+                if (tally.error) {
+                    entry.state = 'failed';
+                    entry.reason = tally.error;
+                }
+                else if (tally.failed > 0) {
+                    entry.state = 'failed';
+                    entry.reason = `${tally.failed} task(s) did not finish: ${tally.failedTitles.join(', ')}`;
+                }
+                else if (tally.paused) {
+                    entry.state = 'stopped';
+                    entry.reason = `paused after ${tally.ran} task(s); ${tally.leftQueued} still queued`;
+                }
+                else if (batch.stopping || tally.leftQueued > 0) {
+                    entry.state = 'stopped';
+                    entry.reason = `${tally.leftQueued} task(s) never started`;
+                }
+                else {
+                    entry.state = 'done';
+                }
+                this.bus.publish({
+                    sessionId: entry.sessionId,
+                    type: 'batch-session-finished',
+                    level: entry.state === 'failed' ? 'warn' : 'info',
+                    message: `this session ended ${entry.state} inside the batch`,
+                    data: { batchId: batch.id, ran: entry.ran, failed: entry.failed },
+                });
+                if (entry.state === 'failed' && batch.onFailure === 'stop') {
+                    batch.stopping = true;
+                    this.bus.publish({
+                        sessionId: entry.sessionId,
+                        type: 'batch-stopped-early',
+                        level: 'warn',
+                        message: 'the batch is set to stop on a failure, so the sessions after this one stay as they are',
+                        data: { batchId: batch.id },
+                    });
+                }
+            }
+        }
+        catch (e) {
+            // Nothing above is expected to throw: a failing run resolves rather than rejects. If
+            // something does, the batch has to end here and say so, because this promise is not
+            // awaited anywhere and an escaping rejection would take the whole API process down.
+            const current = batch.sessions.find((s) => s.state === 'running');
+            if (current) {
+                current.state = 'failed';
+                current.reason = e.message;
+            }
+            this.bus.publish({
+                sessionId: current?.sessionId ?? batch.id,
+                type: 'batch-error',
+                level: 'error',
+                message: e.message,
+            });
+        }
+        finally {
+            for (const entry of batch.sessions) {
+                if (entry.state === 'waiting' || entry.state === 'running') {
+                    entry.state = 'skipped';
+                    entry.reason ??= 'the batch ended before this session ran';
+                }
+            }
+            // The window outlived every session in the batch; it does not outlive the batch.
+            await browser?.close().catch(() => undefined);
+            batch.running = false;
+            batch.finishedAt = new Date().toISOString();
+        }
+    }
+    // --- plans ----------------------------------------------------------------------------
+    /** The brief the operator hands to a chat model, in the language the interface is in. */
+    /**
+     * The persona, assembled: the software part (fixed, this project's), the machine's projects
+     * by path, and the organisation's part (the operator's, edited on the plan page). Returned
+     * whole for copying and in parts for showing, so the page can say which is which.
+     */
+    async planBrief(opts) {
+        // The machine's projects go into the brief by absolute path, so a plan across a front
+        // end, a back end and a test suite is written with the folders that exist rather than
+        // with three paths the chat model had to ask for and the operator typed from memory.
+        const lang = opts.lang === 'bg' ? 'bg' : 'en';
+        const project = await this.project();
+        const projects = [
+            ...(project.rootDir ? [{ name: project.name, rootDir: project.rootDir, repo: project.repoOk, isDefault: true }] : []),
+            ...project.others.map((o) => ({ name: o.name, rootDir: o.rootDir, repo: o.repoOk, isDefault: false })),
+        ];
+        const [organisation, persona, work] = await Promise.all([
+            this.getContext('organisation', lang),
+            this.getContext('persona', lang),
+            this.getContext('work', lang),
+        ]);
+        /*
+         * Whether a run with nobody watching can start here, asked of the same rule the runner applies
+         * at the entrance — so the brief cannot tell Kerrigan the unattended button works while the run
+         * refuses it, which is exactly what the first test of her did.
+         */
+        const cfg = await this.settings.load();
+        const unattendedRule = { mode: 'unattended', allowedPrograms: cfg.execution.allowedPrograms, isolation: cfg.execution.isolation, lockedToConfirm: cfg.policyLock?.maxMode === 'confirm' };
+        const unattendedBlocked = !unattendedPrecondition(unattendedRule)
+            ? undefined
+            : unattendedIsolationRefusal('unattended', cfg.execution.isolation)
+                ? 'isolation'
+                : 'allowlist';
+        return {
+            text: planBrief({
+                lang,
+                projects,
+                organisation: organisation.content,
+                organisationExample: organisation.example,
+                persona: persona.content,
+                personaExample: persona.example,
+                work: work.content,
+                workExample: work.example,
+                unattendedBlocked,
+            }),
+            software: planBrief({ lang, projects }),
+            organisation: organisation.content,
+            customised: organisation.customised,
+            example: organisation.example,
+            persona: persona.content,
+            personaCustomised: persona.customised,
+            personaExample: persona.example,
+            work: work.content,
+            workCustomised: work.customised,
+            workExample: work.example,
+        };
+    }
+    /**
+     * Reads a pasted plan and says what it means, or what is wrong with it.
+     *
+     * A valid plan is also checked against what the store already holds, because the most
+     * likely mistake with this page is not a malformed document: it is pressing the button
+     * twice, or pasting the plan that is already imported instead of the corrected one. That is
+     * reported, not refused — importing the same work twice is a thing people legitimately do.
+     */
+    async checkPlan(text) {
+        await this.init();
+        const check = checkPlan(text ?? '');
+        if (!check.ok)
+            return { ...check, duplicates: [] };
+        /*
+         * A plan can ask for version control in a folder that is not a repository on this machine.
+         * The document is not wrong; this machine is not ready for it. It is refused all the same,
+         * and the message says which of the two it is, because importing it would create sessions
+         * that claim a way back they do not have.
+         */
+        const repoIssues = [];
+        check.plan.sessions.forEach((session, i) => {
+            if (session.vcs?.enabled === false)
+                return;
+            const dir = session.vcs?.repoDir?.trim() || session.mirror?.rootDir?.trim() || '';
+            const reason = repoUnusableReason(dir);
+            if (reason)
+                repoIssues.push({ path: `sessions[${i}].vcs.repoDir`, message: reason });
+            else if (!dir) {
+                repoIssues.push({
+                    path: `sessions[${i}].vcs.repoDir`,
+                    message: 'This session asks for version control but names no repository. Give it the absolute path of a git ' +
+                        'repository, or set "enabled": false for it.',
+                });
+            }
+        });
+        if (repoIssues.length > 0)
+            return { ok: false, issues: repoIssues, warnings: check.warnings, duplicates: [] };
+        return { ...check, duplicates: await this.findDuplicates(check.plan) };
+    }
+    /**
+     * Sessions the store already holds that this plan would create again, task for task.
+     *
+     * Matched on the name and on the text that would actually be sent, in order. Not on the
+     * level 2, the model or the branch names: those are edited on a session after an import, and
+     * a session whose instructions were tightened by hand is still the same session this plan
+     * describes.
+     */
+    async findDuplicates(plan) {
+        const existing = await this.store.listSessions();
+        const out = [];
+        for (const planned of plan.sessions) {
+            const wanted = plannedSessionSignature(planned);
+            const match = existing.find((s) => s.name.trim().toLowerCase() === planned.name.trim().toLowerCase() &&
+                s.tasks.length === planned.tasks.length &&
+                s.tasks.map((t) => taskSignature(t)).join('\u0001') === wanted);
+            if (match) {
+                out.push({ name: match.name, sessionId: match.id, createdAt: match.createdAt, tasks: match.tasks.length });
+            }
+        }
+        return out;
+    }
+    /**
+     * Validates a plan and creates everything in it. Nothing is started.
+     *
+     * A plan that does not validate is refused as a whole rather than imported in part: half a
+     * plan in the session list is harder to recognise, and harder to undo, than none of it.
+     */
+    async importPlan(text) {
+        await this.init();
+        const check = await this.checkPlan(text);
+        if (!check.ok)
+            return { ok: false, check };
+        const cfg = await this.settings.load();
+        /*
+         * The persona in force right now is the one this import carries. Read here, once, and written
+         * into every task, so a session keeps the approach it was created with: changing the field
+         * afterwards changes the next import, not work already queued. The content does not depend on
+         * the language asked for; only the shipped example does.
+         */
+        const persona = (await this.getContext('persona', 'en')).content;
+        const result = await importPlan(this.store, check.plan, (cfg.copilot.defaultModel ?? '').trim(), (cfg.copilot.defaultReviewModel ?? '').trim(), persona);
+        return {
+            ok: true,
+            result: { ...result, warnings: [...check.warnings, ...result.warnings] },
+            summary: check.summary,
+            // The sessions this import has just made a second copy of, reported after the fact for
+            // the same reason it is reported before: so nobody has to notice it in a list.
+            duplicates: check.duplicates,
+        };
+    }
+    // --- approvals ------------------------------------------------------------------------
+    pendingApprovals(sessionId) {
+        return [...this.waiting.values()].map((w) => w.approval).filter((a) => !sessionId || a.sessionId === sessionId);
+    }
+    /**
+     * Answers one pending approval.
+     *
+     * `run-all` is `run` plus a decision about everything after it: the run stops asking. It is
+     * here rather than as a separate endpoint because it is the answer to the question on
+     * screen, and because the step in front of the operator is the one that earns their trust
+     * in the rest. The deny list is untouched by it.
+     */
+    decide(approvalId, action) {
+        const w = this.waiting.get(approvalId);
+        if (!w)
+            return { ok: false };
+        this.waiting.delete(approvalId);
+        if (action === 'run-all')
+            this.setRunMode(w.approval.sessionId, 'unattended');
+        const decision = action === 'run' || action === 'run-all'
+            ? { action: 'run' }
+            : action === 'skip'
+                ? { action: 'skip', reason: 'skipped by the operator' }
+                : { action: 'abort', reason: 'aborted by the operator' };
+        w.resolve(decision);
+        this.bus.publish({ sessionId: w.approval.sessionId, taskId: w.approval.taskId, type: 'approval-decided', level: 'info',
+            message: `step ${w.approval.stepId}: ${action}`, data: { approvalId, action } });
+        return { ok: true };
+    }
+    /**
+     * Switches a run between asking and not asking, while it is running.
+     *
+     * Going to `unattended` also releases whatever is already waiting, because leaving a step
+     * on screen asking a question nobody will answer again is the one outcome this must not
+     * produce. Going back to `confirm` only affects steps that have not been proposed yet.
+     */
+    setRunMode(sessionId, mode) {
+        const run = this.running.get(sessionId);
+        if (!run)
+            return { ok: false };
+        if (run.mode === mode)
+            return { ok: true, mode };
+        /*
+         * "Run the rest without asking" is a request to become an unattended run, so it answers to the
+         * same preconditions as one started that way. Refusing here keeps the button honest: it cannot
+         * hand out an autonomy the run would not have been allowed to start with.
+         */
+        if (mode === 'unattended') {
+            const blocked = unattendedPrecondition({ ...run.policy, mode });
+            if (blocked)
+                return { ok: false, reason: blocked };
+        }
+        run.mode = mode;
+        /*
+         * The authorizer's rules read the mode from this same policy object, so it changes with the run.
+         * Without this line "run the rest without asking" stopped the asking but left the rules believing
+         * a person was watching: the extra unattended rule — no allowed interpreter evaluating a string,
+         * no shell inside a shell — was never applied to the steps that followed, exactly the steps no
+         * one would read.
+         */
+        run.policy.mode = mode;
+        this.bus.publish({
+            sessionId,
+            type: 'run-mode-changed',
+            level: mode === 'unattended' ? 'warn' : 'info',
+            message: mode === 'unattended'
+                ? 'the rest of this run will execute without asking; denied patterns are still refused'
+                : 'every further step will be shown for approval again',
+            data: { mode },
+        });
+        if (mode === 'unattended') {
+            for (const [id, w] of this.waiting) {
+                if (w.approval.sessionId !== sessionId)
+                    continue;
+                // A fetch waits for its own answer: "run the rest without asking" is not an answer to it.
+                if (w.approval.network)
+                    continue;
+                this.waiting.delete(id);
+                w.resolve({ action: 'run' });
+            }
+        }
+        return { ok: true, mode };
+    }
+    runMode(sessionId) {
+        return this.running.get(sessionId)?.mode;
+    }
+    webAuthorizer(policy, signal) {
+        return makeAuthorizer(policy, (step, ctx, held) => new Promise((resolvePromise) => {
+            // The operator may have pressed "run the rest without asking" on an earlier step.
+            // This is checked per step rather than captured once, which is what makes the switch
+            // take effect from the very next step instead of the next run. A held step is the
+            // exception: it is asked about in an unattended run too, which is the point of holding it.
+            if (!held && this.running.get(ctx.sessionId ?? '')?.mode === 'unattended') {
+                resolvePromise({ action: 'run' });
+                return;
+            }
+            const approval = {
+                id: newId('a-'),
+                sessionId: ctx.sessionId ?? '',
+                taskId: ctx.taskId ?? '',
+                stepId: step.id,
+                description: `[${step.shell ?? 'pwsh'}] ${step.cmd}`,
+                createdAt: new Date().toISOString(),
+                ...(held ? { network: held.network } : {}),
+            };
+            if (signal.aborted) {
+                resolvePromise({ action: 'abort', reason: 'stopped by the operator' });
+                return;
+            }
+            this.waiting.set(approval.id, { approval, resolve: resolvePromise });
+            this.bus.publish({ sessionId: approval.sessionId, taskId: approval.taskId, type: 'approval-requested', level: 'warn',
+                message: held
+                    ? `held for the operator — ${held.network}: ${approval.description}`
+                    : `waiting for approval: ${approval.description}`,
+                data: { ...approval } });
+        }));
+    }
+    // --- events ---------------------------------------------------------------------------
+    recentEvents(sessionId) {
+        return this.bus.recent(sessionId);
+    }
+    subscribe(sessionId, handler) {
+        return this.bus.subscribe(sessionId, handler);
+    }
+    // --- version control ----------------------------------------------------------------------
+    /** Whether version control can do its job in this session, asked before a run. */
+    async vcsStatus(sessionId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const git = await gitAvailable();
+        if (!git)
+            return { ok: false, repoDir: '', problem: "git is not installed, or not on this machine's PATH.", git: null };
+        // `branch` is where HEAD is; `work` is where the session's work is. After a per-task run
+        // those differ, and the second is the one the operator is asking about.
+        return { ...(await vcsPreflight(session)), git, work: sessionBranches(session) };
+    }
+    /**
+     * What going back to before a task would do, and then doing it.
+     *
+     * Two calls rather than one because the operator has to read the consequence before they
+     * agree to it: which commits the restored branch will not have, and which branch keeps them.
+     */
+    async restorePreview(sessionId, taskId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const task = session.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error('No such task.');
+        return await restorePreview(session, task);
+    }
+    async restore(sessionId, taskId) {
+        await this.init();
+        if (this.running.has(sessionId)) {
+            return { ok: false, problem: 'This session is running. Stop it before moving the repository to another branch.' };
+        }
+        if (this.batch?.running) {
+            return { ok: false, problem: 'A batch is running. Stop it before moving the repository to another branch.' };
+        }
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const task = session.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error('No such task.');
+        return await restoreToBase(session, task, this.bus);
+    }
+    /**
+     * Everything one run was asked to do, from a given task onward, in the order it would run.
+     *
+     * The run's own record on each session is what makes this answerable. Tasks are stamped when
+     * they start, so after a failure the tasks that never ran carry nothing and the sessions that
+     * were never reached carry nothing either — asking the tasks would return the half of the run
+     * that already happened, which is the opposite of what is wanted.
+     */
+    async affectedByRestart(session, task) {
+        const group = session.runGroup;
+        /** The tasks a session was asked to do in that run, in its own order, falling back to all. */
+        const askedOf = (s) => {
+            const ids = s.runGroup?.id === group?.id ? (s.runGroup?.taskIds ?? []) : [];
+            return ids.length > 0 ? s.tasks.filter((t) => ids.includes(t.id)) : s.tasks;
+        };
+        if (!group) {
+            // No run on record — an older session, or one whose tasks were started by hand. Then the
+            // honest scope is this session alone, from this task onward.
+            const from = session.tasks.findIndex((t) => t.id === task.id);
+            return { sessions: [session], tasks: session.tasks.slice(Math.max(0, from)).map((t) => ({ session, task: t })) };
+        }
+        const all = await this.store.listSessions();
+        const inRun = all.filter((s) => s.runGroup?.id === group.id).sort((a, b) => (a.runGroup?.order ?? 0) - (b.runGroup?.order ?? 0));
+        const out = [];
+        const sessions = [];
+        for (const s of inRun) {
+            // Sessions the run had already finished with are none of this restart's business.
+            if ((s.runGroup?.order ?? 0) < (group.order ?? 0))
+                continue;
+            const mine = s.id === session.id;
+            /*
+             * The session the task is in starts from that task; every session after it starts from
+             * the top, because it was either never reached or its work is downstream of this one.
+             *
+             * The pivot is looked for in what the run was asked to do, and then in the session's own
+             * list. The second lookup is not redundant: a task added since the run is not in the
+             * run's list, and skipping its session because of that would quietly drop the very
+             * session the operator pressed the button on.
+             */
+            let scope = askedOf(s);
+            let start = 0;
+            if (mine) {
+                start = scope.findIndex((t) => t.id === task.id);
+                if (start < 0) {
+                    scope = s.tasks;
+                    start = scope.findIndex((t) => t.id === task.id);
+                    if (start < 0)
+                        continue;
+                }
+            }
+            const slice = scope.slice(start);
+            if (slice.length === 0)
+                continue;
+            sessions.push(s);
+            for (const t of slice)
+                out.push({ session: s, task: t });
+        }
+        return { sessions, tasks: out, group };
+    }
+    /** What starting again from this task would re-queue, and what it would do to the code. */
+    async restartPlan(sessionId, taskId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const task = session.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error('No such task.');
+        const { sessions, tasks, group } = await this.affectedByRestart(session, task);
+        const from = { sessionId: session.id, sessionName: session.name, taskId: task.id, title: task.title, status: task.status };
+        const plan = {
+            ok: tasks.length > 0,
+            problem: tasks.length === 0 ? 'There is nothing to run again from this task.' : undefined,
+            runId: group?.id,
+            runStartedAt: group?.startedAt,
+            from,
+            tasks: tasks.map(({ session: s, task: t }) => ({
+                sessionId: s.id,
+                sessionName: s.name,
+                taskId: t.id,
+                title: t.title,
+                status: t.status,
+                alreadyQueued: t.status === 'queued',
+            })),
+            sessions: sessions.map((s) => ({ id: s.id, name: s.name, tasks: tasks.filter((x) => x.session.id === s.id).length })),
+            restores: [],
+            mode: group?.mode ?? 'unattended',
+            onFailure: group?.onFailure ?? session.onFailure ?? 'stop',
+        };
+        /*
+         * One restore per repository, keyed on the folder rather than on the session.
+         *
+         * Three sessions working in one repository must not take it back three times to three
+         * different commits; the earliest affected task is the one that decides, because that is
+         * the state the whole re-run starts from.
+         */
+        const byRepo = new Map();
+        for (const entry of tasks) {
+            const dir = (entry.session.vcs?.enabled ? entry.session.vcs.repoDir : '')?.trim();
+            if (!dir)
+                continue;
+            // A repository whose affected tasks never ran has nothing to go back to: the run never
+            // touched it. Taking "no base commit recorded" as a refusal blocked "run again from
+            // here" for every plan whose later sessions had not started yet — which is the usual
+            // shape of a run that stopped in the middle.
+            if (!entry.task.startedAt)
+                continue;
+            if (!byRepo.has(dir))
+                byRepo.set(dir, entry);
+        }
+        for (const [dir, entry] of byRepo) {
+            const preview = await restorePreview(entry.session, entry.task);
+            plan.restores.push({
+                repoDir: preview.repoDir || dir,
+                ok: preview.ok,
+                problem: preview.problem,
+                forTask: entry.task.title,
+                baseCommit: preview.baseCommit,
+                branchName: preview.branchName,
+                leftBehind: preview.leftBehind,
+                keptOn: preview.keptOn,
+            });
+        }
+        return plan;
+    }
+    /**
+     * Put the code back, queue the task and everything after it, and start the run again.
+     *
+     * The order matters and is not negotiable: restore first, then queue, then start. Queueing
+     * before restoring would leave a window in which a run could pick up a task against a tree
+     * that has not moved yet, and starting before queueing would run an empty batch.
+     *
+     * `restore` can be turned off, for the case where the repository is already where it should
+     * be, or where version control was never on. `start` can be turned off to do the first two
+     * and stop there, leaving a queue and an untouched Start button — the same shape an import
+     * has, and the same reason: the moment before a run is the one worth being able to stop at.
+     */
+    async restartFrom(sessionId, taskId, opts = {}) {
+        await this.init();
+        const idle = { started: false, requeued: 0, restored: [] };
+        if (this.batch?.running)
+            return { ...idle, reason: 'A run is in progress. Stop it first.' };
+        const plan = await this.restartPlan(sessionId, taskId);
+        if (!plan.ok)
+            return { ...idle, reason: plan.problem };
+        if (plan.sessions.some((s) => this.running.has(s.id))) {
+            return { ...idle, reason: 'One of these sessions is running on its own. Stop it first.' };
+        }
+        const restored = [];
+        if (opts.restore !== false) {
+            for (const entry of plan.restores) {
+                if (!entry.ok)
+                    return { ...idle, reason: `${entry.repoDir}: ${entry.problem ?? 'the restore could not be prepared.'}` };
+            }
+            // Re-read each repository's own pivot and do it for real. The preview above is what the
+            // operator agreed to; this is the same call, one step further.
+            const session = (await this.store.getSession(sessionId));
+            const task = session.tasks.find((t) => t.id === taskId);
+            const { tasks } = await this.affectedByRestart(session, task);
+            const seenRepo = new Set();
+            for (const entry of tasks) {
+                const dir = (entry.session.vcs?.enabled ? entry.session.vcs.repoDir : '')?.trim();
+                if (!dir || seenRepo.has(dir))
+                    continue;
+                seenRepo.add(dir);
+                const done = await restoreToBase(entry.session, entry.task, this.bus);
+                if (!done.ok)
+                    return { ...idle, reason: `${dir}: ${done.problem ?? 'the restore failed.'}` };
+                restored.push(`${dir} -> ${done.branch ?? ''}`);
+            }
+        }
+        let requeued = 0;
+        for (const t of plan.tasks) {
+            if (t.alreadyQueued)
+                continue;
+            try {
+                await this.store.rerunTask(t.sessionId, t.taskId);
+                requeued += 1;
+            }
+            catch (e) {
+                // One task refusing to be queued again must not leave the rest half-reset with no
+                // explanation, so it stops here and says which one and why.
+                return { ...idle, restored, reason: `"${t.title}" could not be queued again: ${e.message}` };
+            }
+        }
+        this.bus.publish({
+            sessionId,
+            taskId,
+            type: 'run-restarted',
+            level: 'info',
+            message: `starting again from "${plan.from.title}": ${plan.tasks.length} task(s) in ${plan.sessions.length} session(s)` +
+                (restored.length > 0 ? `, after taking ${restored.length} repository(ies) back` : ''),
+            data: { requeued, restored },
+        });
+        if (opts.start === false)
+            return { started: false, reason: 'prepared, not started', requeued, restored };
+        const started = await this.startBatch(plan.sessions.map((x) => x.id), opts.mode ?? plan.mode, opts.onFailure ?? plan.onFailure, undefined, undefined, 
+        // Named after the task it goes back to, which is the one thing this run is about and the
+        // only thing a heading could usefully say. There is no field to type into on a task card,
+        // so leaving it to the operator meant leaving it blank every time.
+        await this.suggestRunName(plan.sessions.map((x) => x.id), plan.from.title));
+        return { started: started.started, reason: started.reason, requeued, restored, batch: started.batch };
+    }
+    /** Why a folder cannot be used for version control, or null when it can. */
+    repoProblem(dir) {
+        return repoUnusableReason(dir);
+    }
+    // --- the project being worked on ---------------------------------------------------------
+    /**
+     * The folder new sessions start pointed at, and whether it can carry version control.
+     *
+     * The repository check travels with it because the two questions are always asked together:
+     * somewhere to work, and whether that somewhere can be branched and committed.
+     */
+    async project() {
+        const cfg = await this.settings.load();
+        const rootDir = (cfg.project?.rootDir ?? '').trim();
+        const problem = repoUnusableReason(rootDir);
+        const others = (cfg.project?.others ?? []).map((o) => {
+            const p = repoUnusableReason(o.rootDir);
+            return { name: o.name, rootDir: o.rootDir, repoOk: p === null, ...(p ? { repoProblem: p } : {}), mirror: o.mirror };
+        });
+        return {
+            rootDir,
+            name: (cfg.project?.name ?? '').trim(),
+            repoOk: rootDir !== '' && problem === null,
+            ...(problem ? { repoProblem: problem } : {}),
+            others,
+            mirrorToDesktop: cfg.project?.mirrorToDesktop ?? false,
+            mirror: cfg.project?.mirror,
+            contextRoot: contextRoot(cfg),
+        };
+    }
+    /**
+     * Refreshes every project's Desktop folder, when the switch is on. Called before a run
+     * starts, so what OneDrive holds when the chat opens is the code as it is now, for every
+     * project on the Settings page and not only the one the session is about.
+     */
+    async refreshDesktopMirrors() {
+        const cfg = await this.settings.load();
+        if (!cfg.project?.mirrorToDesktop)
+            return;
+        try {
+            const outcomes = await mirrorAllProjects(cfg);
+            this.bus.publish({
+                sessionId: '*',
+                type: 'desktop-mirror',
+                level: 'info',
+                message: outcomes.map((o) => `${o.name}: ${describeMirror(o.result)}`).join('; ') || 'no projects to mirror',
+            });
+        }
+        catch (e) {
+            this.bus.publish({ sessionId: '*', type: 'desktop-mirror-failed', level: 'warn', message: e.message });
+        }
+    }
+    /**
+     * Stores the project folder and the other folders the operator works in. A field left out
+     * of the patch is kept; an empty `rootDir` clears the default, which is a real choice: it
+     * means new sessions go back to starting with nothing chosen.
+     *
+     * A folder that is not a git repository is allowed here, because this setting is about where
+     * the work is, not about version control. What it cannot do is silently promise version
+     * control, so the answer says, for each folder, whether it can carry it. What is refused is a
+     * folder that is not there, a name used twice, and the default listed again among the others
+     * — each of those would be a setting that looks filled in and points nowhere.
+     */
+    async setProject(patch) {
+        const raw = await this.settings.raw();
+        const current = (raw.project ?? {});
+        const rootDir = patch.rootDir !== undefined ? patch.rootDir.trim() : (current.rootDir ?? '').trim();
+        const name = patch.name !== undefined ? patch.name.trim() : (current.name ?? '').trim();
+        if (rootDir && !existsSync(rootDir))
+            throw new Error(`The folder ${rootDir} does not exist on this machine.`);
+        const others = (patch.others ?? current.others ?? []).map((o) => ({
+            name: (o.name ?? '').trim(),
+            rootDir: (o.rootDir ?? '').trim(),
+            ...(o.mirror ? { mirror: o.mirror } : {}),
+        }));
+        const seen = new Set();
+        for (const o of others) {
+            if (!o.name)
+                throw new Error(`Every other project needs a name; the one at ${o.rootDir || '(no folder)'} has none.`);
+            if (!o.rootDir)
+                throw new Error(`The project "${o.name}" needs a folder.`);
+            if (!existsSync(o.rootDir))
+                throw new Error(`The folder ${o.rootDir} for "${o.name}" does not exist on this machine.`);
+            if (sameFolder(o.rootDir, rootDir))
+                throw new Error(`${o.rootDir} is already the default project; it does not need listing again.`);
+            const key = o.name.toLowerCase();
+            if (seen.has(key))
+                throw new Error(`Two projects are named "${o.name}". Names are how the folders are told apart, so each needs its own.`);
+            seen.add(key);
+        }
+        const mirrorToDesktop = patch.mirrorToDesktop ?? current.mirrorToDesktop ?? false;
+        const mirror = patch.mirror ?? current.mirror;
+        const cfg = await this.settings.save({ ...raw, project: { ...current, rootDir, name, others, mirrorToDesktop, ...(mirror ? { mirror } : {}) } });
+        /*
+         * The switch acts at once, both ways. On: every project's folder appears on the Desktop
+         * now, not at the next run, because "I turned it on and nothing happened" is a support
+         * question. Off: the folders go, because a copy of a code base left in OneDrive after the
+         * operator said no is the one outcome the switch must not produce. A changed selection
+         * with the switch on is applied the same way.
+         */
+        const wasOn = current.mirrorToDesktop ?? false;
+        if (mirrorToDesktop)
+            await mirrorAllProjects(cfg);
+        else if (wasOn)
+            await removeProjectMirrors(cfg);
+        return await this.project();
+    }
+    // --- the model catalogue ----------------------------------------------------------------
+    /**
+     * What the picker offered when it was last read, plus the model new sessions start on.
+     *
+     * The two travel together because the UI shows them in one place: a list to choose from,
+     * and which of them is the standing choice.
+     */
+    async models() {
+        await this.init();
+        const cfg = await this.settings.load();
+        const cached = await this.store.getModels();
+        const defaultModel = cfg.copilot.defaultModel ?? '';
+        const defaultReviewModel = cfg.copilot.defaultReviewModel ?? '';
+        return cached ? { ...cached, defaultModel, defaultReviewModel } : { defaultModel, defaultReviewModel, options: [], readAt: null };
+    }
+    /**
+     * Sets the model a new session's independent review starts on. An empty name clears it,
+     * which means the review runs on the session's own model — the weaker choice, and the one
+     * every session had before this existed.
+     */
+    async setDefaultReviewModel(name) {
+        await this.init();
+        const raw = await this.settings.raw();
+        const copilot = { ...(raw.copilot ?? {}), defaultReviewModel: name.trim() };
+        await this.settings.save({ ...raw, copilot });
+        this.bus.publish({
+            sessionId: '*',
+            type: 'default-review-model-changed',
+            level: 'info',
+            message: name.trim() ? `new sessions will be reviewed by ${name.trim()}` : 'new sessions will be reviewed by their own model',
+        });
+        return { defaultReviewModel: name.trim() };
+    }
+    /**
+     * Sets the model new sessions will start on. An empty name clears it.
+     *
+     * Stored in `data/settings.json` next to the rest of the configuration rather than in the
+     * model cache, because it is a preference of this operator, not a fact about the chat: a
+     * refresh of the list must not be able to change it, and clearing the cache must not lose it.
+     */
+    async setDefaultModel(name) {
+        await this.init();
+        const raw = await this.settings.raw();
+        const copilot = { ...(raw.copilot ?? {}), defaultModel: name.trim() };
+        await this.settings.save({ ...raw, copilot });
+        this.bus.publish({
+            sessionId: '*',
+            type: 'default-model-changed',
+            level: 'info',
+            message: name.trim() ? `new sessions will start on ${name.trim()}` : 'new sessions will start on the chat default',
+        });
+        return { defaultModel: name.trim() };
+    }
+    /**
+     * Reads the model picker from the live chat and caches what it says.
+     *
+     * Expensive and exclusive: it launches the browser with the bot profile, which is the same
+     * profile a run needs, so it cannot happen while a session is running. That is also why the
+     * UI never does this by itself — the user asks for it, and knows a window will open.
+     *
+     * Nothing here decides what a "valid" model is. Whatever the chat lists is what the user
+     * gets to choose from, which is the only way this keeps working when Microsoft changes the
+     * line-up.
+     */
+    async refreshModels() {
+        await this.init();
+        if (this.running.size > 0) {
+            throw new Error('A session is running and it is using the browser profile. Stop it first, then read the models.');
+        }
+        if (this.readingModels)
+            throw new Error('The model list is already being read.');
+        this.readingModels = true;
+        const cfg = await this.settings.load();
+        const transport = new CopilotTransport({
+            profileDir: cfg.resolved.profileDir,
+            transportDir: join(cfg.resolved.runsDir, '_models'),
+            chatUrl: cfg.copilot.url,
+            channel: cfg.copilot.channel,
+            headless: cfg.copilot.headless,
+            replyTimeoutMs: cfg.copilot.replyTimeoutSec * 1000,
+            signInTimeoutMs: cfg.copilot.signInTimeoutSec * 1000,
+            humanWaitMs: cfg.copilot.humanWaitSec * 1000,
+            keepFailurePage: cfg.copilot.keepFailurePage,
+        });
+        try {
+            await transport.open();
+            await transport.ensureSignedIn();
+            const { options, current, note } = await transport.listModels();
+            const catalogue = { options, current: current ?? undefined, readAt: new Date().toISOString(), note };
+            await this.store.saveModels(catalogue);
+            return catalogue;
+        }
+        finally {
+            await transport.close().catch(() => undefined);
+            this.readingModels = false;
+        }
+    }
+    // --- the registry ---------------------------------------------------------------------
+    /**
+     * Every task of every session in one flat list, newest session first and, inside a session,
+     * in the order the tasks run. The page splits it into what is done, what is running and
+     * what is still ahead; doing the flattening here keeps that split honest, because the
+     * queue position is only knowable from the session's own list.
+     */
+    async taskRegistry() {
+        await this.init();
+        const sessions = await this.store.listSessions();
+        const out = [];
+        for (const s of sessions) {
+            let queueSeen = 0;
+            s.tasks.forEach((t, i) => {
+                if (t.status === 'queued')
+                    queueSeen += 1;
+                const started = t.startedAt ? Date.parse(t.startedAt) : undefined;
+                const finished = t.finishedAt ? Date.parse(t.finishedAt) : undefined;
+                out.push({
+                    sessionId: s.id,
+                    sessionName: s.name,
+                    sessionStatus: s.status,
+                    sessionOnFailure: s.onFailure === 'continue' ? 'continue' : 'stop',
+                    sessionRunOrder: s.runGroup?.order,
+                    sessionRunning: this.running.has(s.id),
+                    chatUrl: s.chat?.url,
+                    taskId: t.id,
+                    title: t.title,
+                    status: t.status,
+                    position: i + 1,
+                    queuePosition: t.status === 'queued' ? queueSeen : undefined,
+                    createdAt: t.createdAt,
+                    startedAt: t.startedAt,
+                    finishedAt: t.finishedAt,
+                    durationMs: started && finished ? finished - started : undefined,
+                    iterations: t.iterations,
+                    summary: t.summary,
+                    reason: t.reason,
+                    runId: t.runId,
+                    runGroup: t.runGroup,
+                    review: t.review
+                        ? { verdict: t.review.verdict, findings: t.review.findings?.length ?? 0, stepsRun: t.review.stepsRun }
+                        : undefined,
+                    deviations: t.deviations?.length || undefined,
+                    disputes: t.disputes?.length || undefined,
+                    readOnly: t.readOnly || undefined,
+                    autoRetries: t.autoRetries || undefined,
+                    attempt: t.attempt,
+                    attempts: (t.attempts ?? []).map((a, n) => {
+                        const from = a.startedAt ? Date.parse(a.startedAt) : undefined;
+                        const to = a.finishedAt ? Date.parse(a.finishedAt) : undefined;
+                        return {
+                            attempt: n + 1,
+                            status: a.status,
+                            startedAt: a.startedAt,
+                            finishedAt: a.finishedAt,
+                            durationMs: from && to ? to - from : undefined,
+                            iterations: a.iterations,
+                            summary: a.summary,
+                            reason: a.reason,
+                            runId: a.runId,
+                            branch: a.vcs?.branch,
+                        };
+                    }),
+                });
+            });
+        }
+        return out;
+    }
+    // --- environment ----------------------------------------------------------------------
+    async dirs(root, respectGitignore = true) {
+        return await listSelectableDirs(root, { respectGitignore });
+    }
+    /** Opens the machine's own folder dialog and reports what was picked. */
+    async browseFolder(start) {
+        return await pickFolder(start);
+    }
+    /**
+     * What the current selection would copy, without writing anything. This is how the two
+     * switches become checkable: turn the env one on and the `.env` files move from the skipped
+     * list into the copied one, whatever `.gitignore` says about them.
+     */
+    async previewMirror(input) {
+        const conflicts = findSelectionConflicts(input.includeDirs ?? [], input.excludeDirs ?? []);
+        if (conflicts.length > 0)
+            throw new Error(describeConflicts(conflicts));
+        const cfg = await this.settings.load();
+        const { files, skipped } = await collectFiles({
+            rootDir: input.rootDir,
+            includeDirs: input.includeDirs?.length ? input.includeDirs : ['.'],
+            excludeDirs: input.excludeDirs ?? [],
+            targetDir: '',
+            respectGitignore: input.respectGitignore ?? true,
+            includeEnvFiles: input.includeEnvFiles ?? false,
+            ignoreDirs: cfg.projectMirror.ignoreDirs,
+            maxFileBytes: cfg.projectMirror.maxFileBytes,
+        });
+        let totalBytes = 0;
+        for (const rel of files) {
+            const s = await import('node:fs/promises').then((fs) => fs.stat(join(input.rootDir, rel)).catch(() => null));
+            if (s)
+                totalBytes += s.size;
+        }
+        return { files, skipped, envFiles: files.filter(isEnvPath), totalBytes, conflicts };
+    }
+    async doctor() {
+        const cfg = await this.settings.load();
+        const edge = ['C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe', 'C:/Program Files/Microsoft/Edge/Application/msedge.exe'].find((p) => existsSync(p));
+        const holders = findEdgeUsingProfile(cfg.resolved.profileDir);
+        return {
+            node: process.versions.node,
+            edge: edge ?? null,
+            profileDir: cfg.resolved.profileDir,
+            profileExists: existsSync(cfg.resolved.profileDir),
+            profileHeldBy: Array.isArray(holders) ? holders.map((h) => h.pid) : 'unknown',
+            /*
+             * Whether the bot itself is what holds the profile. While a run is going, Edge is open
+             * on that profile *by the runner*, and the warning "close this Edge window, a run would
+             * fail" was shown in exactly the moment it was false. The page says which it is.
+             */
+            botRunning: this.running.size > 0 || this.batch?.running === true,
+            desktop: resolveDesktopDir(),
+            desktopSynced: desktopIsSynced(),
+            cwd: cfg.resolved.cwd,
+            runsDir: cfg.resolved.runsDir,
+            dataDir: this.dataDir,
+            mode: cfg.execution.mode,
+            /*
+             * Where the bot is running. The only thing that actually contains a command once it runs, and
+             * until now the one thing the System page could not show: a machine that ignored the README's
+             * recommendation looked exactly like one that had followed it. The claim is the operator's and
+             * is shown as a claim; the signals are what can be read. See `exec/isolation.ts`.
+             */
+            isolation: assessIsolation(cfg.execution.isolation, readIsolationSignals()),
+            folderDialog: process.platform === 'win32',
+            alwaysIgnoredDirs: DEFAULT_IGNORE_DIRS,
+        };
+    }
+};
+OperatorService = __decorate([
+    Injectable()
+], OperatorService);
+export { OperatorService };
+/**
+ * Which run folder a request may read.
+ *
+ * Without a `runId` it is the task's current one. With one, it must be a run this task owns:
+ * the current attempt or one of the archived ones. Anything else returns null rather than a
+ * path, so a crafted id cannot walk out of the task's own history.
+ */
+function resolveRunId(task, requested) {
+    if (!task)
+        return null;
+    if (!requested)
+        return task.runId ?? null;
+    const owned = [task.runId, ...(task.attempts ?? []).map((a) => a.runId)].filter(Boolean);
+    return owned.includes(requested) ? requested : null;
+}
+function isEnvPath(relPath) {
+    const name = relPath.split('/').pop()?.toLowerCase() ?? '';
+    return name === '.env' || name.startsWith('.env.');
+}
+/**
+ * Refuses a selection that contradicts itself, at the point it is saved rather than at the
+ * point it runs. A contradiction is cheap to fix while the form is open and expensive to
+ * discover an hour later, when the first task of a run fails on it.
+ */
+function assertMirrorIsCoherent(mirror) {
+    const conflicts = findSelectionConflicts(mirror.includeDirs ?? [], mirror.excludeDirs ?? []);
+    if (conflicts.length > 0) {
+        throw new Error(`The include and exclude lists contradict each other. ${describeConflicts(conflicts)}`);
+    }
+    if (mirror.enabled && mirror.rootDir !== undefined && !mirror.rootDir.trim()) {
+        throw new Error('Attaching project files needs a project root.');
+    }
+}