copilot-operator 0.1.38 → 0.1.39

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

@@ -171,6 +171,16 @@ let OperatorController = class OperatorController {
         const { buildOnFinished, ...patch } = body ?? {};
         return this.ops.rerunTask(id, taskId, patch, { buildOnFinished: buildOnFinished === true }).catch(fail);
     }
+    /** How the task contradicts itself, with the ways out of each contradiction. Changes nothing. */
+    contractCheck(id, taskId) {
+        return this.ops.contractCheck(id, taskId).catch(fail);
+    }
+    /** Applies one chosen fix per contradiction (-1 = none) and queues the task; starts nothing. */
+    applyContractFix(id, taskId, body) {
+        if (body?.expect !== undefined && (!Array.isArray(body.expect) || body.expect.some((x) => typeof x !== 'string')))
+            throw new BadRequestException('expect must be a list of the contradictions shown');
+        return this.ops.applyContractFix(id, taskId, body?.choices ?? [], body?.expect).catch(fail);
+    }
     /** What going back to before this task would do. Changes nothing. */
     restorePreview(id, taskId) {
         return this.ops.restorePreview(id, taskId).catch(fail);
@@ -738,6 +748,23 @@ __decorate([
     __metadata("design:paramtypes", [String, String, Object]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "rerunTask", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/contract'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "contractCheck", null);
+__decorate([
+    Post('sessions/:id/tasks/:taskId/contract-fix'),
+    __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, "applyContractFix", null);
 __decorate([
     Get('sessions/:id/tasks/:taskId/restore'),
     __param(0, Param('id')),

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

@@ -36,8 +36,8 @@ function sameFolder(a, b) {
 }
 import { importPlan, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
 import { readInterruption } from '../session/interruption.js';
-import { branchAt, commitInterrupted, repoDirOf, trackedRepoOf, vcsPreflight, restorePoint, restorePreview, restoreToBase, sessionBranches, sessionBranchName } from '../vcs/taskVcs.js';
-import { branchExists, branchNameFrom, changedFilesBetween, fileAt, freeBranchName, git, gitAvailable, localBranches, plannedBranchName, repoUnusableReason } from '../vcs/git.js';
+import { 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 { makeAuthorizer } from '../exec/authorizer.js';
 import { pickFolder } from './folderPicker.js';
 import { findEdgeUsingProfile } from '../transport/profileLock.js';
@@ -50,7 +50,7 @@ import { planPrepare, prepareFromRemote } from '../vcs/prepareFromRemote.js';
 import { askpassProgram } from '../vcs/remoteAuth.js';
 import { appendRunLog, appendSessionLog } from '../session/runLog.js';
 import { workingDirFor, isWorkingDirProblem } from '../exec/workDir.js';
-import { contractConflicts } from '../orchestrator/contract.js';
+import { contractConflictsWithFixes, contractFixPatch, describeContractChange } from '../orchestrator/contract.js';
 import { checkRefusalForOperator, lineRefusal } from '../orchestrator/taskRunner.js';
 import { preferredShell } from '../exec/shells.js';
 import { sessionRoots } from '../exec/confinement.js';
@@ -63,6 +63,8 @@ import { computeMetrics } from '../session/metrics.js';
 import { resolveDesktopDir, desktopIsSynced } from '../context/desktopDir.js';
 import { saveAndReveal } from './saveToDesktop.js';
 import { settingsOf } from './settings.js';
+/** Why a session set aside on the Sessions page does not run: one sentence for every start that refuses it. */
+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
  * batch and the model picker gave before there was one rule for all three are kept where they still
@@ -966,6 +968,11 @@ let OperatorService = class OperatorService {
         try {
             // A run nobody named is named after what it is a run of, rather than left to show up in the
             // register as "Unnamed run" beside five others of the same description.
+            // Set aside on the Sessions page: said first, before the preflight judges a session that will not run.
+            if ((await this.store.getSession(sessionId))?.active === false) {
+                this.releaseBrowser(claim.holder);
+                return { started: false, reason: INACTIVE_REASON };
+            }
             const chosenName = name?.trim() || (await this.suggestRunName([sessionId]));
             const runGroup = { id: newId('r-'), startedAt: new Date().toISOString(), sessions: 1, name: chosenName };
             // A run of one is still a run, and it records the same thing a batch does, so that going
@@ -1017,7 +1024,7 @@ let OperatorService = class OperatorService {
             return { started: false, reason: 'no such session', done: Promise.resolve(idle) };
         // Set aside by the operator on the Sessions page: not started by anything until made active.
         if (session.active === false) {
-            return { started: false, reason: 'the session is inactive; make it active on the Sessions page to run it', done: Promise.resolve(idle) };
+            return { started: false, reason: INACTIVE_REASON, done: Promise.resolve(idle) };
         }
         const queuedIds = queuedToRun(session, onlyTasks).map((t) => t.id);
         if (queuedIds.length === 0)
@@ -1257,7 +1264,24 @@ let OperatorService = class OperatorService {
             // Version control first, before anything opens the browser: see `vcs/runPreflight.ts`.
             // The batch's id first, so the preflight is recorded under the run it decides about.
             const batchId = newId('b-');
-            const notReady = await this.runPreflight(batchId, wanted, onlyTasks);
+            /*
+             * Sessions set aside on the Sessions page are left out before the preflight: judged there, an inactive
+             * session's contradiction or version-control problem was the answer to the press — and could refuse
+             * the whole batch — although it would never have run (review of 2026-10-09). `prepareBatch` records
+             * them as skipped, with the reason.
+             */
+            const active = [];
+            const inactive = [];
+            for (const id of wanted) {
+                const s = await this.store.getSession(id);
+                if (s?.active === false)
+                    inactive.push(s.name);
+                else
+                    active.push(id);
+            }
+            if (active.length === 0)
+                return { started: false, reason: `${inactive.map((n) => `"${n}"`).join(', ')}: ${INACTIVE_REASON}` };
+            const notReady = await this.runPreflight(batchId, active, onlyTasks);
             if (notReady)
                 return { started: false, reason: notReady };
             const begun = await this.prepareBatch(wanted, onlyTasks, mode, onFailure, model, reviewModel, name, batchId);
@@ -1306,13 +1330,25 @@ let OperatorService = class OperatorService {
                 sessions.push({ sessionId: id, name: id, state: 'skipped', ran: 0, failed: 0, reason: 'no such session' });
                 continue;
             }
+            /*
+             * Set aside on the Sessions page: left out here, before the browser opens, with the reason `start`
+             * gives. Let through, the batch said "started", opened the browser, and only then skipped it — a
+             * "Run" that reported success and ran nothing.
+             */
+            if (s.active === false) {
+                sessions.push({ sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: INACTIVE_REASON });
+                continue;
+            }
             const queued = queuedToRun(s, onlyTasks).length;
             sessions.push(queued === 0
                 ? { sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: onlyTasks ? 'none of its chosen tasks is queued' : 'nothing queued' }
                 : { sessionId: id, name: s.name, state: 'waiting', ran: 0, failed: 0 });
         }
         if (!sessions.some((s) => s.state === 'waiting')) {
-            return { reason: 'none of the selected sessions has a queued task' };
+            const inactive = sessions.filter((s) => s.reason === INACTIVE_REASON);
+            return {
+                reason: inactive.length > 0 ? `${inactive.map((s) => `"${s.name}"`).join(', ')}: ${INACTIVE_REASON}` : 'none of the selected sessions has a queued task',
+            };
         }
         /*
          * The same entrance rule `start` has, asked here too and for the same reason: before a browser
@@ -2152,29 +2188,38 @@ let OperatorService = class OperatorService {
         const next = queuedToRun(session, onlyTasks)[0];
         if (!next)
             return null;
+        const conflicts = await this.contractFor(session, next, afterOthers);
+        return conflicts.length === 0
+            ? null
+            : `The task "${next.title}" of "${session.name}" contradicts itself, so it was not started and stays queued: ${conflicts.map((c) => c.text).join(' ')} Press "Run this task" on it, in the register or on the session's page, and the smallest change that removes it is offered there; or change the prompt, the checks, the scope or read-only on the session's page, and start again.`;
+    }
+    /**
+     * Each way the task contradicts itself, judged as its next attempt would start, with the ways out
+     * (see `ContractFix`). The one judgement behind the refusal at a run's start and behind the fixes
+     * the pages offer, so a fix offered is a fix for the refusal the operator was shown.
+     */
+    async contractFor(session, next, afterOthers = false) {
         const cfg = await this.settings.load();
         const work = workingDirFor(session, cfg.resolved.cwd);
         if (isWorkingDirProblem(work))
-            return null;
+            return [];
         /*
          * The branch the task will be on, where that is known before the run: so a check that expects another
          * branch is refused here too, not after the browser opened and a branch was cut (live run 2026-10-04).
          */
         const prefix = session.vcs?.branchPrefix || 'cop/';
-        const attempt = next.attempt ?? 1;
+        // By the runner's own rules for the attempt's branch; a task that has run is judged as the attempt it would be queued as.
         const branch = !session.vcs?.enabled
             ? undefined
             : session.vcs.startFrom === 'existing-branch'
                 ? session.vcs.existingBranch?.trim() || undefined
                 : session.vcs.branchMode === 'per-session'
                     ? sessionBranchName(session)
-                    : next.vcsPlan?.branch?.trim()
-                        ? plannedBranchName(next.vcsPlan.branch, prefix, attempt)
-                        : branchNameFrom([session.name, next.title, attempt > 1 ? `a${attempt}` : undefined], prefix);
+                    : nextAttemptBranch({ ...session, vcs: { ...session.vcs, branchPrefix: prefix } }, next);
         const files = await this.contractTree(session, afterOthers).catch(() => 'unknown');
         // Input files are carried onto a first start from their last capture: not judged before it (see `contract.ts`).
         const carried = !session.vcsBaseCommit ? inputSettings(session.vcs)?.patterns : undefined;
-        const conflicts = await contractConflicts(next, work.cwd, repoDirOf(session) || work.cwd, { branch, files, carried }).catch(() => []);
+        const conflicts = await contractConflictsWithFixes(next, work.cwd, repoDirOf(session) || work.cwd, { branch, files, carried }).catch(() => []);
         // A plan check the runner refuses for its own command line can never run: the task could never pass.
         const roots = sessionRoots(work.cwd, [cfg.project.rootDir, ...cfg.project.others.map((o) => o.rootDir)]);
         const shell = preferredShell(cfg.execution.defaultShell);
@@ -2183,12 +2228,95 @@ let OperatorService = class OperatorService {
             if (!run)
                 continue;
             const why = lineRefusal(run, c.shell ?? shell, c.cwd ? resolve(work.cwd, c.cwd) : work.cwd, cfg.execution, roots);
-            if (why)
-                conflicts.push(`The check "${c.name}" is refused by the runner for its own command line, so it can never run and the task could never pass: ${checkRefusalForOperator(why)}.`);
+            if (why) {
+                conflicts.push({
+                    text: `The check "${c.name}" is refused by the runner for its own command line, so it can never run and the task could never pass: ${checkRefusalForOperator(why)}.`,
+                    fixes: [{ kind: 'drop-check', check: c.name }],
+                });
+            }
         }
-        return conflicts.length === 0
-            ? null
-            : `The task "${next.title}" of "${session.name}" contradicts itself, so it was not started and stays queued: ${conflicts.join(' ')} Change the prompt, the checks, the scope or read-only on the session's page, and start again.`;
+        return conflicts;
+    }
+    /**
+     * How a task contradicts itself, asked by a page: a task that ended `contract-conflict`, or a queued
+     * one a run refused to start for it. Changes nothing.
+     */
+    async contractCheck(sessionId, taskId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        if (!session)
+            throw new Error('No such session.');
+        const task = session.tasks.find((t) => t.id === taskId);
+        if (!task)
+            throw new Error('No such task.');
+        return { conflicts: await this.contractFor(session, task) };
+    }
+    /**
+     * Applies the chosen way out of each contradiction and puts the task back in the queue.
+     *
+     * `choices` holds one entry per contradiction `contractCheck` names, in its order: the index of the
+     * fix taken, or -1 to leave that one as it is. Judged again here rather than trusted from the page,
+     * and refused when the contradictions are no longer the ones the operator chose from — an edit in
+     * another tab, a check that passes now. A queued task is edited in place; one that has run is queued
+     * again with the change, its attempt kept on the record as any re-run keeps it. Nothing starts.
+     */
+    async applyContractFix(sessionId, taskId, choices, 
+    /** The contradictions the choices were made from, as the page was shown them. */
+    expect) {
+        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.');
+        if (task.status === 'running' || task.status === 'waiting-approval')
+            throw new Error('This task is running. Stop the session first.');
+        const conflicts = await this.contractFor(session, task);
+        // The same ones, not only as many: a fix chosen for one contradiction must not be applied to another.
+        const same = Array.isArray(expect) ? expect.length === conflicts.length && expect.every((x, i) => x === conflicts[i].text) : true;
+        if (!Array.isArray(choices) || choices.length !== conflicts.length || !same) {
+            throw new Error(`The task's contradictions are not the ones shown (${conflicts.length} now). Look again before applying a fix.`);
+        }
+        const chosen = conflicts.flatMap((c, i) => {
+            const at = choices[i] ?? -1;
+            if (at === -1)
+                return [];
+            const fix = Number.isInteger(at) ? c.fixes[at] : undefined;
+            if (!fix)
+                throw new Error(`There is no fix number ${at} for "${c.text}".`);
+            return [fix];
+        });
+        if (chosen.length === 0)
+            throw new Error('No fix was chosen.');
+        const patch = contractFixPatch(task, chosen);
+        const applied = describeContractChange(task, patch);
+        // Judged on the task as it was read: one edited meanwhile, in another tab, is not overwritten with a patch made from the old one.
+        const contract = (t) => JSON.stringify([t?.status, !!t?.readOnly, t?.scope ?? [], t?.checks ?? []]);
+        const meanwhile = (await this.store.getSession(sessionId))?.tasks.find((t) => t.id === taskId);
+        if (contract(meanwhile) !== contract(task))
+            throw new Error('The task was changed while its contradictions were being judged. Look again before applying a fix.');
+        const updated = task.status === 'queued' ? await this.updateTask(sessionId, taskId, patch) : await this.rerunTask(sessionId, taskId, patch);
+        const after = await this.store.getSession(sessionId);
+        const now = after?.tasks.find((t) => t.id === taskId) ?? updated;
+        const remaining = after ? await this.contractFor(after, now) : [];
+        const cfg = await this.settings.load();
+        await appendSessionLog(cfg.resolved.runsDir, sessionId, {
+            type: 'contract-fixed',
+            message: `"${now.title}": ${applied.join('; ')}${remaining.length > 0 ? `; ${remaining.length} contradiction(s) left` : ''}`,
+            data: { taskId, applied: chosen, remaining: remaining.map((c) => c.text) },
+        }).catch(() => undefined);
+        this.bus.publish({
+            sessionId,
+            taskId,
+            type: 'contract-fixed',
+            level: 'info',
+            message: remaining.length === 0
+                ? `"${now.title}" changed so it no longer contradicts itself: ${applied.join('; ')}`
+                : `"${now.title}" changed (${applied.join('; ')}), and it still contradicts itself in ${remaining.length} way(s)`,
+            data: { applied: chosen, remaining: remaining.length },
+        });
+        return { task: now, applied, remaining };
     }
     /**
      * Where the next task's file checks can be judged before the run: see `ContractTree`. The folder holds
@@ -2508,11 +2636,35 @@ let OperatorService = class OperatorService {
         // Asked of the machine as it is now, as `restartFrom` will ask it; see `unattendedRefused`.
         if (plan.mode === 'unattended')
             plan.unattendedRefused = (await this.unattendedRefusal('unattended')) ?? undefined;
+        // The sessions in the order the run had them: the order `rerunFromRestore` moves them in.
+        const inOrder = [...new Map(tasks.map(({ session: s }) => [s.id, s])).values()];
         for (const target of restoreTargets(tasks)) {
             const preview = await restorePreview(target.session, target.task);
             // What would stop the restore itself, asked here as well, so the dialog says it before the
             // operator agrees rather than after.
             const refused = target.problem ?? (await this.restoreRefusal(target.session));
+            /*
+             * What the restart moves besides the first session's line: each later per-session session in this
+             * repository that ran goes onto a new branch, and its own commits stay on the branch it leaves. By
+             * the conditions `rerunFromRestore` applies when it does it, so the list is what will happen.
+             */
+            const listed = new Set(preview.leftBehind);
+            const here = normaliseDir(target.dir);
+            const laterSessions = [];
+            for (const s of inOrder.slice(inOrder.findIndex((x) => x.id === target.session.id) + 1)) {
+                if (!s.vcs?.enabled || s.vcs.branchMode !== 'per-session' || s.vcs.startFrom === 'existing-branch')
+                    continue;
+                if (!s.vcsBaseCommit || normaliseDir(repoDirOf(s)) !== here)
+                    continue;
+                const first = tasks.find((x) => x.session.id === s.id && x.task.startedAt)?.task;
+                if (!first)
+                    continue;
+                const branch = sessionBranchName(s);
+                const from = (s.vcsStart?.kind === 'branch' ? restorePoint(s, first) : undefined) ?? s.vcsBaseCommit;
+                const commits = (await commitsBetween(target.dir, from, branch).catch(() => [])).filter((c) => !listed.has(c));
+                commits.forEach((c) => listed.add(c));
+                laterSessions.push({ sessionName: s.name, branch, commits });
+            }
             plan.restores.push({
                 repoDir: preview.repoDir || target.dir,
                 ok: preview.ok && !refused,
@@ -2522,6 +2674,7 @@ let OperatorService = class OperatorService {
                 branchName: preview.branchName,
                 leftBehind: preview.leftBehind,
                 keptOn: preview.keptOn,
+                ...(laterSessions.length > 0 ? { laterSessions } : {}),
             });
         }
         /*
@@ -2534,6 +2687,17 @@ let OperatorService = class OperatorService {
             plan.ok = false;
             plan.problem = refusedRestores.map((r) => `${r.repoDir}: ${r.problem ?? 'the restore cannot be made'}`).join(' ');
         }
+        /*
+         * A session set aside on the Sessions page would not run, and the run is refused at its start for it:
+         * said here, before anything moves, as the other entrance rules are (review of 2026-10-09: the
+         * repositories were taken back and the tasks queued, and only then was the run refused).
+         */
+        const inactive = sessions.filter((s) => s.active === false);
+        if (inactive.length > 0) {
+            plan.ok = false;
+            plan.inactive = true;
+            plan.problem = `${inactive.map((s) => `"${s.name}"`).join(', ')}: ${INACTIVE_REASON}`;
+        }
         return plan;
     }
     /**
@@ -2554,6 +2718,9 @@ let OperatorService = class OperatorService {
         if (this.batch?.running)
             return { ...idle, reason: 'A run is in progress. Stop it first.' };
         const plan = await this.restartPlan(sessionId, taskId);
+        // A session set aside stops it whatever is asked: its run would be refused after everything moved.
+        if (plan.inactive)
+            return { ...idle, reason: plan.problem };
         // A refused restore stops the restart only when the restore is asked for: `restore: false` queues without one.
         const onlyRestoreRefused = plan.tasks.length > 0 && plan.restores.some((r) => !r.ok);
         if (!plan.ok && !(opts.restore === false && onlyRestoreRefused))

package/dist/src/orchestrator/contract.js

@@ -79,11 +79,68 @@ function branchCheckPasses(check, branch) {
     return null;
 }
 /** Each contradiction in the task, as a sentence; empty when it can be satisfied. */
-export async function contractConflicts(task, cwd, repoDir, 
+export async function contractConflicts(task, cwd, repoDir, vcs = {}) {
+    return (await contractConflictsWithFixes(task, cwd, repoDir, vcs)).map((c) => c.text);
+}
+/**
+ * The contract fixes applied to the task as it is now, as the patch an edit or a re-run takes. In the
+ * order given; a fix naming a check the task no longer has changes nothing. Nothing the operator did not
+ * choose is changed: a read-only task keeps its paths unless "drop-scope" was chosen, even though the two
+ * contradict each other, because leaving that contradiction was the operator's choice.
+ */
+export function contractFixPatch(task, fixes) {
+    let readOnly = !!task.readOnly;
+    let scope = [...(task.scope ?? [])];
+    let checks = [...(task.checks ?? [])];
+    for (const fix of fixes) {
+        if (fix.kind === 'add-to-scope') {
+            if (!scope.includes(fix.path))
+                scope.push(fix.path);
+        }
+        else if (fix.kind === 'not-read-only') {
+            readOnly = false;
+            for (const p of fix.scope)
+                if (!scope.includes(p))
+                    scope.push(p);
+        }
+        else if (fix.kind === 'drop-scope') {
+            scope = [];
+        }
+        else if (fix.kind === 'drop-check') {
+            checks = checks.filter((c) => c.name !== fix.check);
+        }
+    }
+    return { readOnly, scope, checks };
+}
+/**
+ * What changed in the contract, read from before and after rather than from the fixes chosen: two fixes
+ * can pull different ways ("drop the paths" for one contradiction, "allow only this file" for another),
+ * and their descriptions side by side read as a contradiction; the result does not. For a log line or
+ * an event.
+ */
+export function describeContractChange(before, after) {
+    const out = [];
+    if (!!before.readOnly !== !!after.readOnly)
+        out.push(after.readOnly ? 'now read-only' : 'no longer read-only');
+    const was = (before.scope ?? []).join(', ');
+    const now = (after.scope ?? []).join(', ');
+    if (was !== now)
+        out.push(now ? `may change only ${now}${was ? ` (was ${was})` : ''}` : `its list of paths removed (was ${was})`);
+    const kept = new Set((after.checks ?? []).map((c) => c.name));
+    for (const c of before.checks ?? [])
+        if (!kept.has(c.name))
+            out.push(`the check "${c.name}" dropped`);
+    return out;
+}
+/** Each contradiction in the task, with the ways out of it; empty when it can be satisfied. */
+export async function contractConflictsWithFixes(task, cwd, repoDir, 
 /** The branch version control put the task on, when it is on; where its file checks are judged (see `ContractTree`). */
 vcs = {}) {
     const out = [];
     const scope = task.scope ?? [];
+    // Only a check the task itself carries can be dropped from it; a review's check is that review's finding.
+    const own = new Set((task.checks ?? []).map((c) => c.name));
+    const dropIfOwn = (check) => (own.has(check.name) ? [{ kind: 'drop-check', check: check.name }] : []);
     /*
      * A check that the task is on a branch the runner did not choose can never pass: the chat may not
      * switch branches. Seen on 2026-09-30, a check still expecting the recovery branch the session had
@@ -95,12 +152,19 @@ vcs = {}) {
         for (const check of all.filter(readsCurrentBranch)) {
             if (branchCheckPasses(check, vcs.branch) !== false)
                 continue;
-            out.push(`The check "${check.name}" expects another branch, but version control put this task on ${vcs.branch}, and the chat may not switch branches. ` +
-                'To check that earlier work is included, check its commit instead: git merge-base --is-ancestor <commit> HEAD.');
+            out.push({
+                text: `The check "${check.name}" expects another branch, but version control put this task on ${vcs.branch}, and the chat may not switch branches. ` +
+                    'To check that earlier work is included, check its commit instead: git merge-base --is-ancestor <commit> HEAD.',
+                fixes: dropIfOwn(check),
+            });
         }
     }
     if (task.readOnly && scope.length > 0) {
-        out.push(`It is read-only, which allows no change, and also scoped to ${scope.join(', ')}, which allows changes there.`);
+        out.push({
+            text: `It is read-only, which allows no change, and also scoped to ${scope.join(', ')}, which allows changes there.`,
+            // Read-only already means "nowhere", so dropping the paths changes nothing the task could do.
+            fixes: [{ kind: 'drop-scope' }, { kind: 'not-read-only', scope: [...scope] }],
+        });
     }
     if (!task.readOnly && scope.length === 0)
         return out;
@@ -125,10 +189,17 @@ vcs = {}) {
         if (inside && (vcs.carried?.length ?? 0) > 0 && inScope(rel, vcs.carried))
             continue;
         if (task.readOnly) {
-            out.push(`The check "${check.name}" fails now and can only pass if ${rel || path} changes, but the task is read-only.`);
+            out.push({
+                text: `The check "${check.name}" fails now and can only pass if ${rel || path} changes, but the task is read-only.`,
+                // Allowed to change that one file and nothing else: the least a read-only task can be loosened.
+                fixes: [...(inside ? [{ kind: 'not-read-only', scope: [rel] }] : []), ...dropIfOwn(check)],
+            });
         }
         else if (inside && !inScope(rel, scope)) {
-            out.push(`The check "${check.name}" fails now and can only pass if ${rel} changes, but the task's scope (${scope.join(', ')}) leaves that file out.`);
+            out.push({
+                text: `The check "${check.name}" fails now and can only pass if ${rel} changes, but the task's scope (${scope.join(', ')}) leaves that file out.`,
+                fixes: [{ kind: 'add-to-scope', path: rel }, ...dropIfOwn(check)],
+            });
         }
     }
     return out;

package/dist/src/plan/systemGuide.js

@@ -1587,8 +1587,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Run again',
                         bg: 'Пусни отново',
-                        doesEn: 'Puts a finished task back in the queue unchanged, to start afresh; the earlier attempt is kept with its own log. It only queues.',
-                        doesBg: 'Връща приключила задача в опашката без промяна, да тръгне отначало; предишният опит се пази със собствен дневник. Само я нарежда.',
+                        doesEn: 'Puts a finished task back in the queue unchanged, to start afresh; the earlier attempt is kept with its own log. It only queues, then offers "Run this task" on the card.',
+                        doesBg: 'Връща приключила задача в опашката без промяна, да тръгне отначало; предишният опит се пази със собствен дневник. Само я нарежда, после предлага „Пусни тази задача“ на картата.',
                     },
                     {
                         key: 'restore.button',
@@ -2300,8 +2300,64 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Fix the prompt and queue it again',
                         bg: 'Поправи prompt-а и върни в опашката',
-                        doesEn: 'On a row that did not end done, its session idle: rewrite the task\'s text and queue it again. It does not start it.',
-                        doesBg: 'На ред, който не е завършил готов, при спряна сесия: пренапишете текста на задачата и я върнете в опашката. Не я пуска.',
+                        doesEn: 'On a row that did not end done, its session idle: rewrite the task\'s text and queue it again. Saving does not start it; the same dialog then asks "Run it now?" with the "Run this task" choices and buttons.',
+                        doesBg: 'На ред, който не е завършил готов, при спряна сесия: пренапишете текста на задачата и я върнете в опашката. Запазването не я пуска; после същият прозорец пита „Да я пусна ли сега?“ с изборите и бутоните на „Пусни тази задача“.',
+                    },
+                    {
+                        key: 'runq.later',
+                        kind: 'button',
+                        en: 'Later',
+                        bg: 'По-късно',
+                        doesEn: 'On a "Run this task" panel that was offered rather than asked for — after a prompt was saved, a contradiction fixed, or a task queued again on its card: leaves the task waiting in the queue.',
+                        doesBg: 'В панела „Пусни тази задача“, когато е предложен, а не поискан — след запазен prompt, поправено противоречие или задача, върната в опашката от картата ѝ: оставя задачата да чака в опашката.',
+                    },
+                    {
+                        key: 'runq.button',
+                        kind: 'button',
+                        en: 'Run this task',
+                        bg: 'Пусни тази задача',
+                        doesEn: 'On a waiting (queued) row, its session idle and active: a panel to start that task now — "Only this task", or "This one and the N queued after it" in its session. It lists what runs, says the tasks that already ran are not touched, and names an earlier task of a chain that did not succeed (a warning, not a refusal). Also on a queued task card on the session page.',
+                        doesBg: 'На чакащ ред, при спряна и активна сесия: панел за пускане на задачата сега — „Само тази задача“ или „Тази и N чакащи след нея“ в сесията ѝ. Изброява какво ще тръгне, казва, че вече изпълнените задачи не се пипат, и назовава по-ранна задача от верига, която не е минала (предупреждение, не отказ). Има го и на картата на чакаща задача в страницата на сесията.',
+                    },
+                    {
+                        key: 'runq.go',
+                        kind: 'button',
+                        en: 'Run, asking before each command',
+                        bg: 'Пусни, с питане преди всяка команда',
+                        doesEn: 'In "Run this task": starts what the panel lists, step by step. A refusal is said in the panel; if the task contradicts itself, its fixes open right there.',
+                        doesBg: 'В „Пусни тази задача“: пуска изброеното в панела, стъпка по стъпка. Отказът се казва в панела; ако задачата си противоречи, поправките ѝ се отварят там.',
+                    },
+                    {
+                        key: 'runq.unattended',
+                        kind: 'button',
+                        en: 'Run without asking',
+                        bg: 'Пусни без да пита',
+                        doesEn: 'In "Run this task": the same, on its own, without stopping to ask; asks "are you sure" first unless Settings say not to.',
+                        doesBg: 'В „Пусни тази задача“: същото, самостоятелно, без да спира да пита; първо пита „сигурни ли сте“, освен ако настройките не казват друго.',
+                    },
+                    {
+                        key: 'cfix.button',
+                        kind: 'button',
+                        en: 'Fix the contradiction',
+                        bg: 'Поправи противоречието',
+                        doesEn: 'On a row (a dialog) or task card blocked because it contradicts itself (the chip "task contradicts itself"): lists each contradiction with the ways out, the least change chosen — add the file to the scope, let a read-only task change only that file, drop the scope, or drop one of its own checks. Never changes the prompt. A task a run refused to start for this stays queued: its fixes open inside "Run this task".',
+                        doesBg: 'На ред (или карта), блокиран с „задачата си противоречи“: изброява всяко противоречие с изходите от него, като е избрана най-малката промяна — файлът в обхвата, задача само за четене да променя само този файл, без обхват, или без една от собствените ѝ проверки. Prompt-ът никога не се променя.',
+                    },
+                    {
+                        key: 'cfix.apply',
+                        kind: 'button',
+                        en: 'Apply and queue it again',
+                        bg: 'Приложи и върни в опашката',
+                        doesEn: 'Applies the chosen fixes, queues the task as a new attempt and offers "Run this task". Nothing starts by itself.',
+                        doesBg: 'Прилага избраните поправки, връща задачата в опашката като нов опит и предлага „Пусни тази задача“. Нищо не тръгва само.',
+                    },
+                    {
+                        key: 'cfix.applyQueued',
+                        kind: 'button',
+                        en: 'Apply',
+                        bg: 'Приложи',
+                        doesEn: 'The same for a task still waiting (a run refused to start it): edits it where it waits; then start it again from the same panel.',
+                        doesBg: 'Същото за задача, която още чака (пускането е отказано): променя я на място; после я пуснете отново от същия панел.',
                     },
                     {
                         key: 'reg.newPrompt',

package/dist/src/vcs/taskVcs.js

@@ -598,6 +598,27 @@ export function sessionBranches(session) {
 function firstAttemptBase(task) {
     return earliestBase(task);
 }
+/**
+ * The branch a per-task session's task will be put on when its next attempt starts, worked out before the
+ * run by the rules `prepareForTask` applies at the start: a continuation, or a new prompt on finished work,
+ * goes on the previous attempt's branch; an attempt after one that committed nothing goes on that empty
+ * branch again; otherwise the planned or derived name, "-aN" from the second attempt on. A task that has
+ * run is judged as the attempt it would be queued as, by a plain re-run (no continuation). The one thing
+ * not asked here is whether that empty branch still sits where it was cut, which only the start can see.
+ */
+export function nextAttemptBranch(session, task) {
+    const prefix = session.vcs?.branchPrefix || 'cop/';
+    const ran = task.status !== 'queued';
+    const attempt = (task.attempt ?? 1) + (ran ? 1 : 0);
+    const prev = ran ? { vcs: task.vcs } : task.attempts?.at(-1);
+    const carried = !ran && (task.continuing || task.buildsOn) ? task.attempts?.at(-1)?.vcs?.branch : undefined;
+    if (carried)
+        return carried;
+    if (prev?.vcs?.branch && prev.vcs.baseCommit && !prev.vcs.commit && prev.vcs.baseCommit === firstAttemptBase(task))
+        return prev.vcs.branch;
+    const planned = task.vcsPlan?.branch?.trim();
+    return planned ? plannedBranchName(planned, prefix, attempt) : branchNameFrom([session.name, task.title, attempt > 1 ? `a${attempt}` : undefined], prefix);
+}
 async function switchTo(session, task, dir, wantedName, from, bus, 
 /** `mustExist`: carry on this branch or nothing; never create it. */
 opts) {