copilot-operator 0.1.42 → 0.1.43

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

@@ -188,6 +188,16 @@ let OperatorController = class OperatorController {
      * A body with `title`, `prompt` or `level2` edits the task on the way: the attempt that
      * already ran keeps the text it ran with, and the next one uses the new text.
      */
+    /** A note to the chat about this task: sent with its next message, at once while it runs. */
+    addTaskNote(id, taskId, body = {}) {
+        if (typeof body?.text !== 'string' || !body.text.trim())
+            throw new BadRequestException('text is required');
+        return this.ops.addTaskNote(id, taskId, body.text).catch(fail);
+    }
+    /** The operator accepts a task as done that did not end so. */
+    acceptTask(id, taskId, body = {}) {
+        return this.ops.acceptTask(id, taskId, typeof body?.note === 'string' ? body.note : undefined).catch(fail);
+    }
     /** A task that stopped at the runner's limit carries on in its own conversation and branch. */
     continueTask(id, taskId, body = {}) {
         // The operator's new prompt, when one is given: see `TaskContinuation.instruction`.
@@ -216,6 +226,19 @@ let OperatorController = class OperatorController {
     restore(id, taskId) {
         return this.ops.restore(id, taskId).catch(fail);
     }
+    /** What undoing this task would do, both ways: only this task, or back to before it. */
+    undoPreview(id, taskId) {
+        return this.ops.undoPreview(id, taskId).catch(fail);
+    }
+    /** Does it: `this` takes the task's work out (queued again); `back` goes back to before it (it and the later ones queued). */
+    async undoTask(id, taskId, body) {
+        if (body?.how !== 'this' && body?.how !== 'back')
+            throw new BadRequestException('how must be "this" or "back"');
+        const r = await this.ops.undoTask(id, taskId, body.how).catch(fail);
+        if (!r.ok)
+            throw new BadRequestException(r.problem);
+        return r;
+    }
     /** What starting the run again from this task would re-queue, and do to the code. */
     restartPlan(id, taskId) {
         return this.ops.restartPlan(id, taskId).catch(fail);
@@ -501,6 +524,33 @@ let OperatorController = class OperatorController {
     resetContext(kind, lang) {
         return this.ops.resetContext(asContextKind(kind), lang ?? 'en');
     }
+    /** One folder of the session's repository at its branch (or the task's commit): read-only, for the workbench. */
+    repoTree(id, path, task) {
+        return this.ops.repoTree(id, path ?? '', task?.trim() || undefined).catch(fail);
+    }
+    /** One file of it, as text. */
+    repoFile(id, path, task) {
+        if (!path)
+            throw new BadRequestException('path is required');
+        return this.ops.repoFile(id, path, task?.trim() || undefined).catch(fail);
+    }
+    /** The commits on the session's line, each with the task that made it. */
+    repoLog(id) {
+        return this.ops.repoLog(id).catch(fail);
+    }
+    /** What happened in these sessions, for Kerrigan, with the operator's note and the form of her answer. */
+    kerriganReport(body = {}) {
+        const ids = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : []);
+        return this.ops.kerriganReport({ sessionIds: ids(body?.sessionIds), taskIds: ids(body?.taskIds), note: typeof body?.note === 'string' ? body.note : undefined }).catch(fail);
+    }
+    /** Kerrigan's changes to existing work, read against it as it is now; nothing is changed. */
+    checkChanges(body = {}) {
+        return this.ops.checkChanges(typeof body?.text === 'string' ? body.text : '').catch(fail);
+    }
+    /** Applies them one by one, stopping at the first refused; nothing is started. */
+    applyChanges(body = {}) {
+        return this.ops.applyChanges(typeof body?.text === 'string' ? body.text : '').catch(fail);
+    }
     /** Checks a pasted plan without importing anything, and says what it would duplicate. */
     checkPlan(body) {
         return this.ops.checkPlan(body?.text ?? '').catch(fail);
@@ -807,6 +857,24 @@ __decorate([
     __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "deleteTask", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/notes'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "addTaskNote", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/accept'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "acceptTask", null);
 __decorate([
     Post('sessions/:id/tasks/:taskId/continue'),
     __param(0, Param('id')),
@@ -858,6 +926,23 @@ __decorate([
     __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "restore", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/undo'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "undoPreview", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/undo'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "undoTask", null);
 __decorate([
     Get('sessions/:id/tasks/:taskId/restart'),
     __param(0, Param('id')),
@@ -1111,6 +1196,52 @@ __decorate([
     __metadata("design:paramtypes", [String, String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "resetContext", null);
+__decorate([
+    Get('sessions/:id/repo/tree'),
+    __param(0, Param('id')),
+    __param(1, Query('path')),
+    __param(2, Query('task')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "repoTree", null);
+__decorate([
+    Get('sessions/:id/repo/file'),
+    __param(0, Param('id')),
+    __param(1, Query('path')),
+    __param(2, Query('task')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "repoFile", null);
+__decorate([
+    Get('sessions/:id/repo/log'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "repoLog", null);
+__decorate([
+    Post('kerrigan/report'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "kerriganReport", null);
+__decorate([
+    Post('changes/check'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "checkChanges", null);
+__decorate([
+    Post('changes/apply'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "applyChanges", null);
 __decorate([
     Post('plan/check'),
     __param(0, Body()),

package/dist/src/api/operator.service.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
@@ -572,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.
      *
@@ -2194,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
@@ -2802,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

@@ -381,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"