copilot-operator 0.1.42 → 0.1.44

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

@@ -45,10 +45,12 @@ 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 { workspaceFile, workspaceFiles, workspaceInfo } from '../session/workspace.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 +82,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 +590,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 +2240,279 @@ let OperatorService = class OperatorService {
             duplicates: check.duplicates,
         };
     }
+    // --- the workspace and its chat (2026-10-17, "like Windsurf") ------------------------------
+    /** The project folder the workbench has open: Settings → the default project. */
+    async workspace() {
+        await this.init();
+        const cfg = await this.settings.load();
+        return await workspaceInfo(cfg.project?.rootDir ?? '', cfg.project?.name ?? '');
+    }
+    async workspaceFiles() {
+        const ws = await this.workspace();
+        if (!ws.ok)
+            throw new Error(ws.problem ?? 'No project folder is open.');
+        return { dir: ws.dir, ...(await workspaceFiles(ws.dir)) };
+    }
+    async workspaceFile(path) {
+        const ws = await this.workspace();
+        if (!ws.ok)
+            throw new Error(ws.problem ?? 'No project folder is open.');
+        return await workspaceFile(ws.dir, path);
+    }
+    /** The chat's conversations, newest first. */
+    async chatThreads() {
+        await this.init();
+        return (await this.store.listSessions())
+            .filter((s) => s.kind === 'chat')
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+            .map((s) => ({ id: s.id, name: s.name, createdAt: s.createdAt, status: s.status, turns: s.tasks.length, running: this.running.has(s.id), repoDir: s.vcs?.repoDir || s.projectDir }));
+    }
+    /**
+     * A message written in the chat. With no conversation yet, one is made in the open project folder: a session of
+     * kind `chat`, one branch for all of it, no independent review, plan mode off, so each message is answered as
+     * it would be in an IDE's chat. The message becomes a task of it, queued; the caller starts it (the start window
+     * the first time, where the work starts being asked once). While the conversation is working, the message is a
+     * note to the task in flight, which the chat gets with its next report.
+     */
+    async chatSend(input) {
+        await this.init();
+        const text = (input.text ?? '').trim();
+        if (!text)
+            throw new Error('The message is empty.');
+        if (text.length > MAX_INSTRUCTION_CHARS)
+            throw new Error(`The message is ${text.length} characters; it can be at most ${MAX_INSTRUCTION_CHARS}.`);
+        let session = input.threadId ? await this.store.getSession(input.threadId) : null;
+        if (input.threadId && (!session || session.kind !== 'chat'))
+            throw new Error('That conversation is not there any more. Start a new one.');
+        if (session) {
+            const inFlight = session.tasks.find((t) => t.status === 'running' || t.status === 'waiting-approval');
+            if (inFlight && this.running.has(session.id)) {
+                await this.addTaskNote(session.id, inFlight.id, text);
+                return { threadId: session.id, taskId: inFlight.id, noted: true, needsStart: false };
+            }
+        }
+        else {
+            const ws = await this.workspace();
+            if (!ws.ok)
+                throw new Error(ws.problem ?? 'No project folder is open.');
+            const title = text.split(/\r?\n/)[0].trim().slice(0, 60);
+            const created = await this.store.createSession(`chat: ${title}`, ws.dir);
+            session = await this.store.updateSession(created.id, (s) => {
+                s.kind = 'chat';
+                s.onFailure = 'continue';
+                s.review = { enabled: false, model: '' };
+                s.planMode = 'off';
+                s.vcs = ws.isRepo
+                    ? {
+                        ...(s.vcs ?? DEFAULT_VCS),
+                        enabled: true,
+                        repoDir: ws.dir,
+                        branchMode: 'per-session',
+                        // The operator's own uncommitted work is normal in an open folder: taken along as the conversation's
+                        // starting snapshot, once they approve it, rather than refusing the first message.
+                        dirtyWorktree: { policy: 'snapshot' },
+                    }
+                    : { ...(s.vcs ?? DEFAULT_VCS), enabled: false, repoDir: '' };
+                s.projectDir = ws.dir;
+            });
+            this.bus.publish({ sessionId: session.id, type: 'chat-started', level: 'info', message: `a conversation in ${ws.dir}` });
+        }
+        const task = await this.store.addTask(session.id, {
+            title: text.split(/\r?\n/)[0].trim().slice(0, 80) || 'message',
+            level2: '',
+            prompt: text,
+        });
+        const fresh = (await this.store.getSession(session.id));
+        return { threadId: fresh.id, taskId: task.id, needsStart: !fresh.vcsStart && !fresh.tasks.some((t) => t.startedAt) };
+    }
+    // --- 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 +3121,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"