copilot-operator 0.1.41 → 0.1.43

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

@@ -20,7 +20,7 @@ import { join, resolve } from 'node:path';
 import { installLayout } from '../config/layout.js';
 import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW, applyDefaultProject, applyTaskPatch } from '../session/store.js';
 import { EventBus } from '../session/events.js';
-import { freshRetriesOfLatestRun, isContinuable, newId } from '../session/model.js';
+import { freshRetriesOfLatestRun, isContinuable, MAX_INSTRUCTION_CHARS, newId } from '../session/model.js';
 import { runSession, openBrowser, queuedToRun } from '../orchestrator/taskRunner.js';
 import { buildExport } from '../session/exportRecord.js';
 import { buildDebugExport } from '../session/debugExport.js';
@@ -45,10 +45,11 @@ 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 { composeLevel2, composePrompt, importPlan, personaBlock, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
+import { checkChanges, kerriganReport } from '../plan/changes.js';
 import { readInterruption } from '../session/interruption.js';
-import { baseRefOf, branchAt, commitInterrupted, nextAttemptBranch, repoDirOf, trackedRepoOf, vcsPreflight, restorePoint, restorePreview, restoreToBase, sessionBranches, sessionBranchName } from '../vcs/taskVcs.js';
-import { branchExists, changedFilesBetween, commitsBetween, fileAt, freeBranchName, git, gitAvailable, localBranches, plannedBranchName, repoUnusableReason } from '../vcs/git.js';
+import { baseRefOf, branchAt, commitInterrupted, nextAttemptBranch, repoDirOf, trackedRepoOf, vcsPreflight, restorePoint, restorePreview, restoreToBase, revertTaskWork, undoThisPreview, sessionBranches, sessionBranchName } from '../vcs/taskVcs.js';
+import { branchExists, changedFilesBetween, commitsBetween, fileAt, freeBranchName, git, gitAvailable, localBranches, looksLikeRepo, plannedBranchName, repoUnusableReason } from '../vcs/git.js';
 import { makeAuthorizer } from '../exec/authorizer.js';
 import { pickFolder } from './folderPicker.js';
 import { findEdgeUsingProfile } from '../transport/profileLock.js';
@@ -80,6 +81,22 @@ import { saveAndReveal } from './saveToDesktop.js';
 import { settingsOf, SettingsUnusableError } from './settings.js';
 import { PolicyLockUnusableError } from '../config/lockedPolicy.js';
 /** Why a session set aside on the Sessions page does not run: one sentence for every start that refuses it. */
+/** The id of the task a change names by id, number or title; see `plan/changes.ts`. */
+function checkTaskRef(session, ref) {
+    if (typeof ref === 'number' || /^\d+$/.test(String(ref)))
+        return session.tasks[Number(ref) - 1]?.id;
+    return (session.tasks.find((t) => t.id === ref) ?? session.tasks.find((t) => t.title === ref) ?? session.tasks.find((t) => t.title.toLowerCase() === String(ref).toLowerCase()))?.id;
+}
+/** Why this task cannot be undone now, or null: only a task that ran and is not running or queued. */
+function undoRefusalOf(task) {
+    if (task.status === 'queued')
+        return 'This task is queued and has not run since; there is nothing of it to undo.';
+    if (task.status === 'running' || task.status === 'waiting-approval')
+        return 'This task is running. Stop it first.';
+    if (!task.startedAt)
+        return 'This task has not run; there is nothing of it to undo.';
+    return null;
+}
 const INACTIVE_REASON = 'the session is inactive; make it active on the Sessions page to run it';
 /**
  * Why the browser cannot be had now, said in terms of what was pressed. The sentences a start, a
@@ -436,6 +453,12 @@ let OperatorService = class OperatorService {
             }
             if (patch.projectDir !== undefined)
                 s.projectDir = patch.projectDir.trim();
+            if (patch.planMode !== undefined) {
+                if (patch.planMode === 'off' || patch.planMode === 'auto' || patch.planMode === 'approve')
+                    s.planMode = patch.planMode;
+                else
+                    delete s.planMode;
+            }
             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
@@ -566,6 +589,34 @@ let OperatorService = class OperatorService {
         await this.init();
         await this.store.deleteTask(sessionId, taskId);
     }
+    /**
+     * A note to the chat about a task (2026-10-14): queued, running or waiting, it goes out with the task's
+     * next message — at once, in effect, for a task that is running. See `Task.notes`.
+     */
+    async addTaskNote(sessionId, taskId, text) {
+        await this.init();
+        const task = await this.store.addTaskNote(sessionId, taskId, text);
+        const running = this.running.has(sessionId) && ['running', 'waiting-approval'].includes(task.status);
+        this.bus.publish({ sessionId, taskId, type: 'task-note-added', level: 'info',
+            message: running ? 'a note from the operator; it goes to the chat with the next report' : 'a note from the operator; it goes to the chat when the task runs next',
+            data: { length: text.trim().length, running } });
+        return task;
+    }
+    /** The operator accepts a task as done that did not end so (2026-10-14). */
+    async acceptTask(sessionId, taskId, note) {
+        await this.init();
+        if (this.running.has(sessionId)) {
+            const now = (await this.store.getSession(sessionId))?.tasks.find((t) => t.id === taskId);
+            if (now && ['running', 'waiting-approval'].includes(now.status))
+                throw new Error('This task is running. Stop it first.');
+        }
+        const task = await this.store.acceptTask(sessionId, taskId, note);
+        const message = `"${task.title}" accepted as done by the operator (it had ended ${task.accepted?.was})${task.accepted?.note ? `: ${task.accepted.note}` : ''}`;
+        this.bus.publish({ sessionId, taskId, type: 'task-accepted', level: 'info', message, data: { was: task.accepted?.was } });
+        const cfg = await this.settings.load();
+        await appendSessionLog(cfg.resolved.runsDir, sessionId, { type: 'accept', message, data: { taskId, was: task.accepted?.was } }).catch(() => undefined);
+        return task;
+    }
     /**
      * Puts a finished task back in the queue, keeping the record of what it already did.
      *
@@ -574,7 +625,12 @@ let OperatorService = class OperatorService {
      * the old attempt's summary sitting under a question that was never asked.
      */
     /** "Continue" on a task that stopped before it finished — a limit from the settings, the bot stopping, the operator: same chat, same branch, fresh count. */
-    async continueTask(sessionId, taskId) {
+    async continueTask(sessionId, taskId, 
+    /**
+     * The operator's new prompt: what carries a task that failed on from where it got to, in its chat and
+     * on its branch (2026-10-13); optional with any other Continue. See `TaskContinuation.instruction`.
+     */
+    instruction) {
         await this.init();
         /*
          * An attempt the operator stopped: which of its last steps ran, and what they printed, read from its
@@ -584,15 +640,21 @@ let OperatorService = class OperatorService {
         const before = (await this.store.getSession(sessionId))?.tasks.find((t) => t.id === taskId);
         const cfg = await this.settings.load();
         const stoppedAt = before?.status === 'aborted' && !before.interruption && before.runId ? await readInterruption(join(cfg.resolved.runsDir, before.runId)).catch(() => null) : null;
-        const task = await this.store.continueTask(sessionId, taskId, stoppedAt);
-        await appendSessionLog(cfg.resolved.runsDir, sessionId, { type: 'continue', message: `"${task.title}" queued to continue as attempt ${task.attempt ?? 1}`, data: { taskId, attempt: task.attempt } }).catch(() => undefined);
+        const task = await this.store.continueTask(sessionId, taskId, stoppedAt, instruction);
+        const after = task.continuing?.how === 'failed' ? ` after it ended ${task.continuing.ended?.status ?? 'failed'}` : '';
+        const withPrompt = task.continuing?.instruction ? ', with a new prompt' : '';
+        await appendSessionLog(cfg.resolved.runsDir, sessionId, {
+            type: 'continue',
+            message: `"${task.title}" queued to continue as attempt ${task.attempt ?? 1}${after}${withPrompt}`,
+            data: { taskId, attempt: task.attempt, ...(task.continuing?.instruction ? { instruction: task.continuing.instruction } : {}) },
+        }).catch(() => undefined);
         this.bus.publish({
             sessionId,
             taskId,
             type: 'task-requeued',
             level: 'info',
-            message: `"${task.title}" is queued to continue where it stopped (attempt ${task.attempt ?? 1})`,
-            data: { attempt: task.attempt, continuing: true },
+            message: `"${task.title}" is queued to continue where it ${after ? 'ended' : 'stopped'}${after}${withPrompt} (attempt ${task.attempt ?? 1})`,
+            data: { attempt: task.attempt, continuing: true, ...(task.continuing?.instruction ? { instruction: true } : {}) },
         });
         return task;
     }
@@ -1130,8 +1192,16 @@ let OperatorService = class OperatorService {
                     x.vcsBaseCommit = undefined;
                     x.vcsStart = undefined;
                 }
+                // Chosen again after the session ran: a re-run starts from it too, and a per-session line goes on under a new name.
+                if (applied.restart) {
+                    x.startRechosenAt = new Date().toISOString();
+                    if (applied.restart.freshBranch) {
+                        x.vcs.branchName = applied.restart.freshBranch;
+                        x.vcs.branchNameExact = true;
+                    }
+                }
             });
-            const message = `${applied.said}${applied.note ? `; ${applied.note}` : ''}${applied.clearStart ? '; the start prepared before (a starting snapshot) no longer applies' : ''}`;
+            const message = `${applied.said}${applied.note ? `; ${applied.note}` : ''}${applied.clearStart && !applied.restart ? '; the start prepared before (a starting snapshot) no longer applies' : ''}`;
             entries.push({ at: new Date().toISOString(), type: 'start-chosen', message, data: { session: id, choice: starts[id], ...(applied.note ? { note: applied.note } : {}) } });
             this.bus.publish({ sessionId: id, type: 'start-chosen', level: 'info', message, data: { runId, choice: starts[id] } });
             await appendSessionLog(cfg.resolved.runsDir, id, { type: 'start-chosen', message, data: { runId, choice: starts[id] } }).catch(() => undefined);
@@ -1323,6 +1393,8 @@ let OperatorService = class OperatorService {
                     await this.store.saveModels({ options, current: current ?? undefined, readAt: new Date().toISOString() });
                 },
             },
+            // Plan mode `approve`: the plan is put to the operator on the approvals card.
+            approvePlan: (ask) => this.askPlanApproval(ask, controller.signal),
         })
             .then(async (outcome) => {
             const tally = { ...(await this.tally(sessionId, queuedIds)), paused: outcome.paused, ...(outcome.refused ? { refused: outcome.refused } : {}) };
@@ -2167,6 +2239,194 @@ let OperatorService = class OperatorService {
             duplicates: check.duplicates,
         };
     }
+    // --- the repository, read-only, for the workbench (2026-10-14) ------------------------------
+    /**
+     * Where a session's work is in its repository: the session's branch in per-session mode, the task's own
+     * branch when one is named, else what is checked out. Read-only; nothing here moves anything.
+     */
+    async repoRefOf(sessionId, taskId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const dir = repoDirOf(session);
+        if (!dir || !looksLikeRepo(dir))
+            throw new Error('This session has no repository to show.');
+        const task = taskId ? session.tasks.find((t) => t.id === taskId) : undefined;
+        const candidates = [
+            ...(task?.vcs?.commit ? [task.vcs.commit] : []),
+            ...(session.vcs?.enabled && session.vcs.branchMode === 'per-session' ? [sessionBranchName(session)] : []),
+            'HEAD',
+        ];
+        for (const ref of candidates) {
+            const r = await git(dir, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]);
+            if (r.ok && r.stdout)
+                return { dir, ref: r.stdout, label: ref === 'HEAD' ? 'HEAD' : ref.length >= 40 ? ref.slice(0, 8) : ref };
+        }
+        throw new Error('The repository has no commit to show yet.');
+    }
+    /** One folder of the repository at that point: its folders and files, folders first. */
+    async repoTree(sessionId, path = '', taskId) {
+        const clean = path.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+        if (clean.split('/').some((p) => p === '..'))
+            throw new Error('That path is not inside the repository.');
+        const { dir, ref, label } = await this.repoRefOf(sessionId, taskId);
+        const r = await git(dir, ['ls-tree', '-l', clean ? `${ref}:${clean}` : ref]);
+        if (!r.ok)
+            throw new Error(clean ? `There is no folder ${clean} there.` : 'The repository could not be read.');
+        const entries = r.stdout
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const [meta, name] = line.split('\t');
+            const [, type, , size] = (meta ?? '').split(/\s+/);
+            return { name: name ?? '', path: clean ? `${clean}/${name}` : (name ?? ''), type: type === 'tree' ? 'dir' : 'file', ...(type === 'blob' && size && size !== '-' ? { size: Number(size) } : {}) };
+        })
+            .filter((e) => e.name)
+            .sort((a, b) => (a.type === b.type ? a.name.localeCompare(b.name) : a.type === 'dir' ? -1 : 1));
+        return { ref, label, path: clean, entries };
+    }
+    /** One file of the repository at that point, as text; a binary or very large file is said to be one. */
+    async repoFile(sessionId, path, taskId) {
+        const clean = path.replace(/\\/g, '/').replace(/^\/+/, '');
+        if (!clean || clean.split('/').some((p) => p === '..'))
+            throw new Error('That path is not inside the repository.');
+        const { dir, ref, label } = await this.repoRefOf(sessionId, taskId);
+        const got = await fileAt(dir, ref, clean, 2 * 1024 * 1024);
+        if (!got.bytes && !got.tooLarge)
+            throw new Error(`There is no file ${clean} there.`);
+        const binary = !!got.bytes && got.bytes.subarray(0, 8000).includes(0);
+        return { ref, label, path: clean, text: got.bytes && !binary ? got.bytes.toString('utf8').replace(/^/, '') : null, binary, tooLarge: got.tooLarge };
+    }
+    /** The commits on the session's line, newest first, each with the task that made it when one did. */
+    async repoLog(sessionId, limit = 60) {
+        const { dir, ref, label } = await this.repoRefOf(sessionId);
+        const session = (await this.store.getSession(sessionId));
+        const r = await git(dir, ['log', `-${Math.max(1, Math.min(limit, 300))}`, '--format=%H%x09%an%x09%aI%x09%s', ref]);
+        const byCommit = new Map();
+        for (const t of session.tasks) {
+            for (const v of [t.vcs, ...(t.attempts ?? []).map((a) => a.vcs)])
+                if (v?.commit)
+                    byCommit.set(v.commit, t);
+        }
+        const commits = (r.ok ? r.stdout.split('\n').filter(Boolean) : []).map((line) => {
+            const [sha = '', author = '', at = '', subject = ''] = line.split('\t');
+            const task = byCommit.get(sha);
+            return { sha, subject, author, at, ...(task ? { taskId: task.id, taskTitle: task.title } : {}) };
+        });
+        return { ref, label, commits };
+    }
+    // --- Kerrigan: what happened, and her changes to existing work (2026-10-14) ---------------------
+    /** What happened in these sessions (all, when none are named), for Kerrigan, with the operator's note. */
+    async kerriganReport(opts = {}) {
+        await this.init();
+        const all = await this.store.listSessions();
+        const wanted = (opts.sessionIds ?? []).filter(Boolean);
+        const taskIds = (opts.taskIds ?? []).filter(Boolean);
+        const sessions = all.filter((s) => (wanted.length > 0 ? wanted.includes(s.id) : taskIds.length > 0 ? s.tasks.some((t) => taskIds.includes(t.id)) : true));
+        if (sessions.length === 0)
+            throw new Error('None of these sessions exists.');
+        if ((opts.note ?? '').length > MAX_INSTRUCTION_CHARS)
+            throw new Error(`The note is ${(opts.note ?? '').length} characters; it can be at most ${MAX_INSTRUCTION_CHARS}.`);
+        return { text: kerriganReport(sessions, { note: opts.note, taskIds }), sessions: sessions.length };
+    }
+    /** Kerrigan's answer read against the sessions as they are now; nothing is changed. */
+    async checkChanges(text) {
+        await this.init();
+        return checkChanges(text ?? '', await this.store.listSessions());
+    }
+    /**
+     * Applies Kerrigan's changes one by one, through the paths the buttons use, and stops at the first that is
+     * refused, saying which were done. Nothing is started.
+     */
+    async applyChanges(text) {
+        const check = await this.checkChanges(text);
+        if (!check.ok)
+            return { ok: false, check, applied: [] };
+        const cfg = await this.settings.load();
+        const persona = (await this.getContext('persona', 'en')).content;
+        const applied = [];
+        for (const r of check.changes) {
+            const c = r.change;
+            try {
+                switch (c.op) {
+                    case 'addTask': {
+                        const session = await this.store.getSession(r.sessionId);
+                        if (!session)
+                            throw new Error('The session is gone.');
+                        const afterId = c.after !== undefined ? checkTaskRef(session, c.after) : undefined;
+                        const reference = afterId ? session.tasks.find((t) => t.id === afterId) : session.tasks.at(-1);
+                        const level2 = c.task.level2.trim()
+                            ? composeLevel2({ level2: '', goal: '' }, c.task, persona)
+                            : (reference?.level2 ?? personaBlock(persona));
+                        const added = await this.store.addTask(r.sessionId, {
+                            title: c.task.title,
+                            level2,
+                            prompt: composePrompt(c.task),
+                            vcsPlan: c.task.vcs,
+                            checks: c.task.checks,
+                            reviewEnabled: c.task.review,
+                            readOnly: c.task.readOnly || undefined,
+                            scope: c.task.scope.length > 0 ? c.task.scope : undefined,
+                            outputs: c.task.outputs.length > 0 ? c.task.outputs : undefined,
+                        });
+                        if (afterId) {
+                            await this.store.updateSession(r.sessionId, (s) => {
+                                const from = s.tasks.findIndex((t) => t.id === added.id);
+                                const [moved] = s.tasks.splice(from, 1);
+                                s.tasks.splice(s.tasks.findIndex((t) => t.id === afterId) + 1, 0, moved);
+                            });
+                        }
+                        break;
+                    }
+                    case 'editTask':
+                        await this.updateTask(r.sessionId, r.taskId, {
+                            ...(c.title ? { title: c.title } : {}),
+                            ...(c.prompt ? { prompt: c.prompt } : {}),
+                            ...(c.checks ? { checks: c.checks } : {}),
+                            ...(c.scope ? { scope: c.scope } : {}),
+                        });
+                        break;
+                    case 'removeTask':
+                        await this.deleteTask(r.sessionId, r.taskId);
+                        break;
+                    case 'continue':
+                        await this.continueTask(r.sessionId, r.taskId, c.instruction);
+                        break;
+                    case 'newPrompt':
+                        await this.rerunTask(r.sessionId, r.taskId, { prompt: c.prompt }, { buildOnFinished: true });
+                        break;
+                    case 'runAgain':
+                        await this.rerunTask(r.sessionId, r.taskId, c.prompt ? { prompt: c.prompt } : {});
+                        break;
+                    case 'undo': {
+                        const done = await this.undoTask(r.sessionId, r.taskId, c.how);
+                        if (!done.ok)
+                            throw new Error(done.problem ?? 'it could not be undone');
+                        break;
+                    }
+                    case 'accept':
+                        await this.acceptTask(r.sessionId, r.taskId, c.note);
+                        break;
+                    case 'note':
+                        await this.addTaskNote(r.sessionId, r.taskId, c.text);
+                        break;
+                }
+                applied.push({ index: r.index, says: r.says });
+                await appendSessionLog(cfg.resolved.runsDir, r.sessionId, { type: 'kerrigan-change', message: r.says, data: { op: c.op, ...(r.taskId ? { taskId: r.taskId } : {}) } }).catch(() => undefined);
+                this.bus.publish({ sessionId: r.sessionId, ...(r.taskId ? { taskId: r.taskId } : {}), type: 'kerrigan-change', level: 'info', message: `from Kerrigan's answer: ${r.says}` });
+            }
+            catch (e) {
+                return {
+                    ok: false,
+                    applied,
+                    failedAt: r.index,
+                    problem: `Change ${r.index + 1} (${r.says}) was refused: ${e.message}${applied.length > 0 ? ` The ${applied.length} before it were made.` : ' Nothing was changed.'}`,
+                };
+            }
+        }
+        return { ok: true, applied };
+    }
     // --- approvals ------------------------------------------------------------------------
     /**
      * Asks the operator to choose the model in the Copilot window, when the runner could not (operator's
@@ -2196,6 +2456,54 @@ let OperatorService = class OperatorService {
                 message: `choose "${ask.asked}" in the Copilot window, then answer on the card`, data: { approvalId: approval.id, model: approval.model } });
         });
     }
+    /**
+     * A task's plan, put to the operator (plan mode `approve`, in a run that asks before each command): it
+     * waits on the approvals card, on every page, until it is approved, sent back for another, or the task
+     * is stopped. See `PlanMode`.
+     */
+    askPlanApproval(ask, signal) {
+        return new Promise((resolveAnswer) => {
+            if (signal.aborted) {
+                resolveAnswer({ decision: 'stop' });
+                return;
+            }
+            const approval = {
+                id: newId('a-'),
+                sessionId: ask.sessionId,
+                taskId: ask.taskId,
+                stepId: 0,
+                description: `The plan of "${ask.title}" (version ${ask.plan.version})`,
+                createdAt: new Date().toISOString(),
+                plan: { title: ask.title, plan: ask.plan },
+            };
+            this.waiting.set(approval.id, {
+                approval,
+                resolve: (d) => resolveAnswer(d.action === 'run' ? { decision: 'approve' } : { decision: 'stop' }),
+                resolvePlan: resolveAnswer,
+            });
+            this.bus.publish({ sessionId: ask.sessionId, taskId: ask.taskId, type: 'approval-requested', level: 'warn',
+                message: `the plan of "${ask.title}" (version ${ask.plan.version}) is waiting for you to approve it`, data: { approvalId: approval.id, plan: true } });
+        });
+    }
+    /**
+     * Answers a plan waiting for approval: approve it (with a note the chat is given beside it), ask for
+     * another (saying what to change), or stop the task.
+     */
+    decidePlan(approvalId, action, note) {
+        const w = this.waiting.get(approvalId);
+        if (!w || !w.resolvePlan)
+            return { ok: false, problem: 'That plan is not waiting any more.' };
+        const text = (note ?? '').trim();
+        if (action === 'revise' && !text)
+            return { ok: false, problem: 'Say what to change in the plan, so the chat knows what the next one must do differently.' };
+        if (text.length > MAX_INSTRUCTION_CHARS)
+            return { ok: false, problem: `The note is ${text.length} characters; it can be at most ${MAX_INSTRUCTION_CHARS}.` };
+        this.waiting.delete(approvalId);
+        w.resolvePlan({ decision: action, ...(text ? { note: text } : {}) });
+        this.bus.publish({ sessionId: w.approval.sessionId, taskId: w.approval.taskId, type: 'approval-decided', level: 'info',
+            message: `plan: ${action}${text ? ' (with a note)' : ''}`, data: { approvalId, action, plan: true } });
+        return { ok: true };
+    }
     pendingApprovals(sessionId) {
         return [...this.waiting.values()].map((w) => w.approval).filter((a) => !sessionId || a.sessionId === sessionId);
     }
@@ -2727,6 +3035,105 @@ let OperatorService = class OperatorService {
         const refused = await this.restoreRefusal(session);
         return refused ? { ...preview, ok: false, problem: refused } : preview;
     }
+    /**
+     * What undoing this task would do, both ways (operator's request, 2026-10-14): "Undo only this task" — its
+     * work taken out of the session's line, what came after it kept — and "Go back to before this task" — the
+     * line put back at its start, it and the tasks after it queued again, nothing started. See `undoTask`.
+     */
+    async undoPreview(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 notYet = undoRefusalOf(task);
+        const refused = notYet ?? (await this.restoreRefusal(session));
+        const own = await undoThisPreview(session, task);
+        const back = await this.restartPlan(sessionId, taskId);
+        return {
+            this: refused ? { ...own, ok: false, problem: refused } : own,
+            back: refused ? { ...back, ok: false, problem: refused } : back,
+            ...(refused ? { problem: refused } : {}),
+        };
+    }
+    /**
+     * Undoes a task that ran. `this`: its work is taken out of the session's line by a revert (per-session),
+     * or the folder is put back at its start (per-task); the task goes back to the queue. `back`: "Run again
+     * from here" without the run — the line goes back to the task's start and it and the tasks after it are
+     * queued. Nothing is started and nothing in git is deleted: the old branch or the reverted commits stay.
+     */
+    async undoTask(sessionId, taskId, how) {
+        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 notYet = undoRefusalOf(task);
+        if (notYet)
+            return { ok: false, problem: notYet };
+        const refused = await this.restoreRefusal(session);
+        if (refused)
+            return { ok: false, problem: refused };
+        const cfg = await this.settings.load();
+        const at = new Date().toISOString();
+        if (how === 'back') {
+            const plan = await this.restartPlan(sessionId, taskId);
+            const r = await this.restartFrom(sessionId, taskId, { restore: true, start: false });
+            if (r.reason && r.requeued === 0)
+                return { ok: false, problem: r.reason };
+            for (const t of plan.tasks.filter((x) => !x.alreadyQueued)) {
+                await this.store
+                    .updateSession(t.sessionId, (s) => {
+                    const last = s.tasks.find((x) => x.id === t.taskId)?.attempts?.at(-1);
+                    if (last)
+                        last.undone = { how: 'back', at, ...(r.restored[0] ? { branch: r.restored[0] } : {}), ...(t.taskId !== taskId ? { byTask: taskId } : {}) };
+                })
+                    .catch(() => undefined);
+            }
+            const message = `went back to before "${task.title}": ${r.requeued} task(s) queued again${r.restored.length > 0 ? `, the code on ${r.restored.join(', ')}` : ''}; nothing was started`;
+            await appendSessionLog(cfg.resolved.runsDir, sessionId, { type: 'undo', message, data: { taskId, how, requeued: r.requeued, restored: r.restored } }).catch(() => undefined);
+            this.bus.publish({ sessionId, taskId, type: 'task-undone', level: 'info', message, data: { how, requeued: r.requeued } });
+            return { ok: true, message, requeued: r.requeued };
+        }
+        let done = {};
+        if (session.vcs?.enabled && session.vcs.branchMode === 'per-task') {
+            const preview = await undoThisPreview(session, task);
+            if (!preview.ok)
+                return { ok: false, problem: preview.problem };
+            if (!preview.nothing) {
+                const back = await restoreToBase(session, task, this.bus);
+                if (!back.ok)
+                    return { ok: false, problem: back.problem };
+                done = { branch: back.branch };
+            }
+            else
+                done = { nothing: preview.nothing };
+        }
+        else {
+            const r = await revertTaskWork(session, task, this.bus);
+            if (!r.ok)
+                return { ok: false, problem: r.problem };
+            done = { commit: r.commit, branch: r.branch, nothing: r.nothing };
+        }
+        await this.store.rerunTask(sessionId, taskId, {});
+        await this.store.updateSession(sessionId, (s) => {
+            const last = s.tasks.find((x) => x.id === taskId)?.attempts?.at(-1);
+            if (last)
+                last.undone = { how: 'this', at, ...(done.commit ? { commit: done.commit } : {}), ...(done.branch ? { branch: done.branch } : {}) };
+        });
+        const message = done.commit
+            ? `took the work of "${task.title}" out of ${done.branch} in ${done.commit.slice(0, 8)}; the task is queued again, nothing was started`
+            : done.branch
+                ? `put the folder back as it was before "${task.title}", on ${done.branch}; its own branch is kept, the task is queued again`
+                : `${done.nothing ?? 'nothing in git to take out'} The task is queued again.`;
+        await appendSessionLog(cfg.resolved.runsDir, sessionId, { type: 'undo', message, data: { taskId, how, ...done } }).catch(() => undefined);
+        this.bus.publish({ sessionId, taskId, type: 'task-undone', level: 'info', message, data: { how, ...done } });
+        return { ok: true, message, requeued: 1 };
+    }
     async restore(sessionId, taskId) {
         await this.init();
         const session = await this.store.getSession(sessionId);

package/dist/src/api/server.js

@@ -108,6 +108,22 @@ export async function startApi(opts = {}) {
     const allowedOrigins = [WEB_ORIGIN, WEB_ORIGIN.replace('localhost', '127.0.0.1'), `http://127.0.0.1:${PORT}`, `http://localhost:${PORT}`];
     app.use(localApiGuard({ token, port: PORT, allowedOrigins, servesInterface: webDir !== null }));
     if (webDir) {
+        /*
+         * A page whose name is also a folder of pages: `/sessions` is `sessions.html`, and `sessions/` holds
+         * `view.html` (2026-10-14, when the list moved there). The static server finds the folder first and
+         * redirects to it, where there is no page; the page is served instead.
+         */
+        const root = webDir;
+        app.use((req, res, next) => {
+            if ((req.method === 'GET' || req.method === 'HEAD') && /^\/[a-z0-9-]+$/i.test(req.path)) {
+                const page = join(root, `${req.path.slice(1)}.html`);
+                if (existsSync(page) && existsSync(join(root, req.path.slice(1)))) {
+                    res.sendFile(page);
+                    return;
+                }
+            }
+            next();
+        });
         // The prebuilt interface, from the package: one process, one port, no dev server.
         app.useStaticAssets(webDir, { extensions: ['html'], index: 'index.html' });
     }

package/dist/src/cli.js

@@ -17,6 +17,7 @@ import { createInterface } from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
 import { loadConfig, expandPath } from './config/schema.js';
 import { CopilotTransport } from './transport/copilotTransport.js';
+import { parseChatId } from './transport/chatSession.js';
 import { runSession } from './orchestrator/taskRunner.js';
 import { SessionStore } from './session/store.js';
 import { settingsOf, SettingsUnusableError } from './api/settings.js';
@@ -384,6 +385,7 @@ program
     .option('--json', 'print the raw list, for pasting into an issue')
     .option('--set <name>', 'also switch the chat to this model, by its exact name')
     .option('--steps', 'with --set: print each step of the choice with its time, and keep a picture of each in runs/_models')
+    .option('--chat <id-or-address>', 'first open this existing conversation (its id, or its address from the browser), as a task carried on does')
     .action(async (opts) => {
     const transport = new CopilotTransport({
         profileDir: opts.profile,
@@ -400,6 +402,16 @@ program
     try {
         await transport.open();
         await transport.ensureSignedIn();
+        /*
+         * Back in a conversation that already ran, as a failed task carried on is: the case the operator saw
+         * the model check go wrong in (2026-10-14). What the picker button reads there is printed first.
+         */
+        if (opts.chat) {
+            const id = parseChatId(opts.chat) ?? opts.chat.trim();
+            const opened = await transport.openConversation(id);
+            console.log(opened ? `opened the conversation ${id}` : `the conversation ${id} could not be opened; going on in the page as it is`);
+            console.log(`the picker button reads: ${(await transport.currentModel()) ?? '(nothing)'}`);
+        }
         const { options, current, note } = await transport.listModels();
         if (opts.json) {
             console.log(JSON.stringify({ current, note, options }, null, 2));

package/dist/src/config/schema.js

@@ -149,6 +149,13 @@ export const RunConfigSchema = z.object({
          * there, a fetch included, is put in front of a person anyway.
          */
         networkFetch: z.enum(['ask', 'refuse', 'run']).default('ask'),
+        /**
+         * Plan mode, for every session that does not set its own (see `PlanMode` in session/model.ts): a
+         * task's chat first looks at the project read-only and replies with a plan, and the work begins once
+         * the plan is approved — by the runner (`auto`), or by the operator (`approve`, in a run that asks
+         * before each command; a run without asking approves it itself). Off by default: it costs messages.
+         */
+        planMode: z.enum(['off', 'auto', 'approve']).default('off'),
         /**
          * The shell a step or a check runs in when it names none of its own.
          *
@@ -374,6 +381,16 @@ export const RunConfigSchema = z.object({
          * its record. Zero turns it off.
          */
         retryBlockedInFreshChat: z.number().int().nonnegative().default(2),
+        /**
+         * How many times a task a limit stopped is carried on at once, in its own chat and from where it got
+         * to, before it waits for the operator's "Continue" (operator's request, 2026-10-14: keep going until
+         * the task is done, like Claude Code, with the limits as the bound). Every limit above counts —
+         * messages, minutes, the reply wait, replies in the wrong shape, rounds of fixing checks or review
+         * findings — so a task gets at most (autoContinue + 1) times each of them. The loop guards (repeats,
+         * no progress) do not carry on: they end a task as blocked, which a fresh chat may cure, then a person.
+         * Zero turns it off.
+         */
+        autoContinue: z.number().int().min(0).max(20).default(3),
         /*
          * How many genuinely different approaches the chat must have tried before it may end a task
          * "blocked". The reply format's own floor is 2 (replySchema.ts); this raises it. A "blocked"