copilot-operator 0.1.10 → 0.1.12

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

@@ -457,7 +457,7 @@ let OperatorController = class OperatorController {
     /** Stores it. A field left out is kept; an empty `rootDir` clears the default. */
     setProject(body) {
         return this.ops
-            .setProject({ rootDir: body?.rootDir, name: body?.name, others: body?.others, mirrorToDesktop: body?.mirrorToDesktop, mirror: body?.mirror })
+            .setProject({ rootDir: body?.rootDir, name: body?.name, others: body?.others, mirrorToDesktop: body?.mirrorToDesktop, mirror: body?.mirror, desktop: body?.desktop })
             .catch(fail);
     }
     /**
@@ -466,6 +466,10 @@ let OperatorController = class OperatorController {
      * Separate from the session's own preflight because that one only speaks when version
      * control is already on, and the question here is whether it may be turned on.
      */
+    /** The command that brings a project's branch back to its remote's main — shown, never run. */
+    repoSync(dir) {
+        return this.ops.syncPlan(dir ?? '').catch(fail);
+    }
     repo(dir) {
         const problem = this.ops.repoProblem(dir ?? '');
         return problem ? { ok: false, problem } : { ok: true };
@@ -994,6 +998,13 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "setProject", null);
+__decorate([
+    Get('repo/sync'),
+    __param(0, Query('dir')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "repoSync", null);
 __decorate([
     Get('repo'),
     __param(0, Query('dir')),

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

@@ -15,11 +15,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Injectable } from '@nestjs/common';
 import { readFile, readdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { installLayout } from '../config/layout.js';
 import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW, applyTaskPatch } from '../session/store.js';
 import { EventBus } from '../session/events.js';
-import { newId } from '../session/model.js';
+import { isContinuable, newId } from '../session/model.js';
 import { runSession, openBrowser, queuedToRun } from '../orchestrator/taskRunner.js';
 import { buildExport } from '../session/exportRecord.js';
 import { buildDebugExport } from '../session/debugExport.js';
@@ -47,10 +47,17 @@ import { assessIsolation, readIsolationSignals, unattendedIsolationRefusal } fro
 import { unattendedPrecondition } from '../exec/policy.js';
 import { createTransport } from '../transport/chatTransport.js';
 import { composeHandoff } from '../session/handoff.js';
+import { planSync } from '../vcs/syncCommand.js';
 import { computeMetrics } from '../session/metrics.js';
 import { resolveDesktopDir, desktopIsSynced } from '../context/contextFiles.js';
 import { saveAndReveal } from './saveToDesktop.js';
 import { Settings } from './settings.js';
+/** A folder as compared: absolute, forward slashes, no trailing slash, and case folded as Windows does. */
+function normaliseDir(dir) {
+    if (!dir.trim())
+        return '';
+    return resolve(dir.trim()).replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+}
 let OperatorService = class OperatorService {
     /** Where this install keeps its prompts and its records. See `config/layout.ts`. */
     layout = installLayout();
@@ -228,9 +235,16 @@ let OperatorService = class OperatorService {
     }
     async updateSession(id, patch) {
         await this.init();
+        if (patch.active !== undefined && this.running.has(id)) {
+            throw new Error('This session is running; its status can be changed once it has stopped.');
+        }
         return await this.store.updateSession(id, (s) => {
             if (patch.name !== undefined)
                 s.name = patch.name.trim() || s.name;
+            if (patch.active === true)
+                delete s.active;
+            else if (patch.active === false)
+                s.active = false;
             if (patch.onFailure === 'stop' || patch.onFailure === 'continue')
                 s.onFailure = patch.onFailure;
             // An empty string is a real choice here: it means "leave the chat on whatever it is".
@@ -317,7 +331,7 @@ let OperatorService = class OperatorService {
      * the text it ran with, and only then is the new text applied. Editing in place would leave
      * the old attempt's summary sitting under a question that was never asked.
      */
-    /** "Continue" on a task that stopped before it finished — its limit, the bot stopping, the operator: same chat, same branch, fresh count. */
+    /** "Continue" on a task that stopped before it finished — a limit from the settings, the bot stopping, the operator: same chat, same branch, fresh count. */
     async continueTask(sessionId, taskId) {
         await this.init();
         const task = await this.store.continueTask(sessionId, taskId);
@@ -742,6 +756,10 @@ let OperatorService = class OperatorService {
         const session = await this.store.getSession(sessionId);
         if (!session)
             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) };
+        }
         const queuedIds = queuedToRun(session, onlyTasks).map((t) => t.id);
         if (queuedIds.length === 0)
             return { started: false, reason: 'no queued tasks', done: Promise.resolve(idle) };
@@ -797,6 +815,8 @@ let OperatorService = class OperatorService {
             // The mode as it is now, not as it was: "run the rest without asking" changes it mid-run,
             // and the policy.json of a later task must say so.
             currentMode: () => this.running.get(sessionId)?.mode ?? mode,
+            // The Desktop copies follow the work while it happens, not only before the run.
+            onWorkChanged: () => this.requestDesktopRefresh(),
             // The session decides whether its tasks are one chain or a set of independent checks.
             continueOnFailure: session.onFailure === 'continue',
             transport,
@@ -1774,6 +1794,26 @@ let OperatorService = class OperatorService {
     repoProblem(dir) {
         return repoUnusableReason(dir);
     }
+    /**
+     * What bringing a project back to its remote's main branch would lose, and the command that does
+     * it — for the operator to run. See `vcs/syncCommand.ts`; nothing here writes.
+     *
+     * Only for a folder this bot already works in: a project in Settings or the repository of a
+     * session. The answer lists file names and commit subjects, and a local page asking about any
+     * folder on the disk is not a question this API should answer.
+     */
+    async syncPlan(dir) {
+        await this.init();
+        const wanted = normaliseDir(dir);
+        const cfg = await this.settings.load();
+        const known = new Set([cfg.project?.rootDir ?? '', ...(cfg.project?.others ?? []).map((o) => o.rootDir), ...(await this.store.listSessions()).flatMap((s) => [s.vcs?.repoDir ?? '', s.mirror?.rootDir ?? ''])]
+            .filter((d) => d.trim())
+            .map(normaliseDir));
+        if (!wanted || !known.has(wanted)) {
+            throw new Error('That folder is not one of the projects in Settings or the repository of a session, so no command is offered for it.');
+        }
+        return await planSync(resolve(dir.trim()));
+    }
     // --- the project being worked on ---------------------------------------------------------
     /**
      * The folder new sessions start pointed at, and whether it can carry version control.
@@ -1787,7 +1827,7 @@ let OperatorService = class OperatorService {
         const problem = repoUnusableReason(rootDir);
         const others = (cfg.project?.others ?? []).map((o) => {
             const p = repoUnusableReason(o.rootDir);
-            return { name: o.name, rootDir: o.rootDir, repoOk: p === null, ...(p ? { repoProblem: p } : {}), mirror: o.mirror };
+            return { name: o.name, rootDir: o.rootDir, repoOk: p === null, ...(p ? { repoProblem: p } : {}), mirror: o.mirror, desktop: o.desktop !== false };
         });
         return {
             rootDir,
@@ -1796,10 +1836,42 @@ let OperatorService = class OperatorService {
             ...(problem ? { repoProblem: problem } : {}),
             others,
             mirrorToDesktop: cfg.project?.mirrorToDesktop ?? false,
+            desktop: cfg.project?.desktop !== false,
             mirror: cfg.project?.mirror,
             contextRoot: contextRoot(cfg),
         };
     }
+    desktopRefresh = null;
+    desktopRefreshAgain = false;
+    /**
+     * Asks for the Desktop copies to be brought up to date, while a run works.
+     *
+     * They used to be refreshed once, before a run, so a task that changed files left the Desktop —
+     * and OneDrive, and the chat that reads from it — on the code as it was before the task. The
+     * runner now calls this after every round of steps and after every task. One refresh runs at a
+     * time: a request that arrives while one is running is remembered and served by one more pass
+     * after it, so a burst of rounds costs two passes, not one per round, and the last pass always
+     * sees the latest files. A failure is reported and never stops the run.
+     */
+    requestDesktopRefresh() {
+        if (this.desktopRefresh) {
+            this.desktopRefreshAgain = true;
+            return;
+        }
+        this.desktopRefresh = (async () => {
+            do {
+                this.desktopRefreshAgain = false;
+                await this.refreshDesktopMirrors();
+            } while (this.desktopRefreshAgain);
+        })().finally(() => {
+            this.desktopRefresh = null;
+        });
+    }
+    /** Resolves once no Desktop refresh is running or waiting. For the checks, and for a clean stop. */
+    async desktopRefreshSettled() {
+        while (this.desktopRefresh)
+            await this.desktopRefresh;
+    }
     /**
      * Refreshes every project's Desktop folder, when the switch is on. Called before a run
      * starts, so what OneDrive holds when the chat opens is the code as it is now, for every
@@ -1814,8 +1886,8 @@ let OperatorService = class OperatorService {
             this.bus.publish({
                 sessionId: '*',
                 type: 'desktop-mirror',
-                level: 'info',
-                message: outcomes.map((o) => `${o.name}: ${describeMirror(o.result)}`).join('; ') || 'no projects to mirror',
+                level: outcomes.some((o) => o.problem) ? 'warn' : 'info',
+                message: outcomes.map((o) => `${o.name}: ${o.result ? describeMirror(o.result) : `not refreshed — ${o.problem}`}`).join('; ') || 'no projects to mirror',
             });
         }
         catch (e) {
@@ -1844,6 +1916,8 @@ let OperatorService = class OperatorService {
             name: (o.name ?? '').trim(),
             rootDir: (o.rootDir ?? '').trim(),
             ...(o.mirror ? { mirror: o.mirror } : {}),
+            // Stored only when it is off: absent means the project goes to the Desktop with the rest.
+            ...(o.desktop === false ? { desktop: false } : {}),
         }));
         const seen = new Set();
         for (const o of others) {
@@ -1862,7 +1936,12 @@ let OperatorService = class OperatorService {
         }
         const mirrorToDesktop = patch.mirrorToDesktop ?? current.mirrorToDesktop ?? false;
         const mirror = patch.mirror ?? current.mirror;
-        const cfg = await this.settings.save({ ...raw, project: { ...current, rootDir, name, others, mirrorToDesktop, ...(mirror ? { mirror } : {}) } });
+        const desktop = patch.desktop ?? current.desktop ?? true;
+        const { desktop: _old, ...rest } = current;
+        const cfg = await this.settings.save({
+            ...raw,
+            project: { ...rest, rootDir, name, others, mirrorToDesktop, ...(mirror ? { mirror } : {}), ...(desktop === false ? { desktop: false } : {}) },
+        });
         /*
          * The switch acts at once, both ways. On: every project's folder appears on the Desktop
          * now, not at the next run, because "I turned it on and nothing happened" is a support
@@ -2027,6 +2106,12 @@ let OperatorService = class OperatorService {
                     readOnly: t.readOnly || undefined,
                     scope: t.scope?.length ? t.scope : undefined,
                     stopCode: t.stopCode,
+                    limit: t.limit,
+                    continuable: isContinuable(t) || undefined,
+                    branch: t.vcs?.branch,
+                    commit: t.vcs?.commit,
+                    vcsProblem: t.vcs?.problem,
+                    sessionInactive: s.active === false || undefined,
                     autoRetries: t.autoRetries || undefined,
                     attempt: t.attempt,
                     changedFiles: t.vcs?.commit && t.vcs.baseCommit ? (t.vcs.files?.length ?? 0) : undefined,

package/dist/src/config/schema.js

@@ -47,10 +47,17 @@ const TextOrFile = z.union([z.string(), z.object({ file: z.string().min(1) })]);
 /** One of git's own options, before the subcommand: `-C <path>`, `--no-pager`, `-c k=v`. */
 const GIT_GLOBAL_OPTION = '(?:--no-pager|--paginate|--bare|--literal-pathspecs|--exec-path=\\S*|-c\\s+\\S+|' +
     '-C\\s+(?:"[^"]*"|\'[^\']*\'|\\S+)|--git-dir[= ]\\S+|--work-tree[= ]\\S+)';
-/** Subcommands that have no read-only form at all. */
+/**
+ * Subcommands that have no read-only form at all.
+ *
+ * Matched as a whole subcommand, followed by neither a letter nor a hyphen: `merge` must not catch
+ * `merge-base`, which only reads (refused live on 2026-09-30, while a task checked that its branch
+ * held a checkpoint). The hyphenated ones that do write are therefore listed by their full name.
+ */
 const GIT_ALWAYS_WRITES = 'commit|push|reset|rebase|merge|cherry-pick|revert|clean|checkout|switch|restore|stash|' +
     'am|apply|init|clone|filter-branch|filter-repo|update-ref|update-index|gc|prune|repack|' +
-    'submodule|worktree|mv|rm|add|pull';
+    'submodule|worktree|mv|rm|add|pull|' +
+    'checkout-index|commit-tree|merge-file|merge-index|merge-one-file|read-tree|prune-packed|update-server-info';
 /** Subcommands that read by default and write with these arguments. */
 const GIT_SOMETIMES_WRITES = 'remote\\s+(?:add|remove|rm|rename|set-url|set-head|set-branches|prune)\\b|' +
     'branch\\s+(?:-[dDmMfu]\\b|--(?:delete|move|copy|force|set-upstream-to|unset-upstream))|' +
@@ -238,7 +245,7 @@ export const RunConfigSchema = z.object({
             'Disable-WindowsOptionalFeature',
             'net\\s+user\\s+\\w+\\s+/add',
             // git that changes something. See GIT_WRITE_NOTE below.
-            `\\bgit\\s+(?:${GIT_GLOBAL_OPTION}\\s+)*(?:${GIT_ALWAYS_WRITES})\\b`,
+            `\\bgit\\s+(?:${GIT_GLOBAL_OPTION}\\s+)*(?:${GIT_ALWAYS_WRITES})(?![\\w-])`,
             `\\bgit\\s+(?:${GIT_GLOBAL_OPTION}\\s+)*(?:${GIT_SOMETIMES_WRITES})`,
         ]),
     })
@@ -285,6 +292,8 @@ export const RunConfigSchema = z.object({
             rootDir: z.string().trim().min(1),
             /** Which of this project's directories go to the Desktop. See `mirror` below. */
             mirror: ProjectMirrorSelection.optional(),
+            /** `false` keeps this project off the Desktop while the switch below is on. Absent means on. */
+            desktop: z.boolean().optional(),
         }))
             .default([]),
         /**
@@ -299,6 +308,8 @@ export const RunConfigSchema = z.object({
         mirrorToDesktop: z.boolean().default(false),
         /** The default project's own selection. */
         mirror: ProjectMirrorSelection.optional(),
+        /** `false` keeps the default project off the Desktop while the switch is on. Absent means on. */
+        desktop: z.boolean().optional(),
     })
         .prefault({}),
     /**
@@ -399,6 +410,12 @@ export const RunConfigSchema = z.object({
          * its record. Zero turns it off.
          */
         retryBlockedInFreshChat: z.number().int().nonnegative().default(2),
+        /*
+         * 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"
+         * with fewer is sent back asking for another approach (see taskRunner.ts). Settings → Execution.
+         */
+        minApproachesBeforeBlocked: z.number().int().min(2).max(50).default(2),
     })
         .prefault({}),
     runsDir: z.string().default('./runs'),

package/dist/src/context/desktopMirror.js

@@ -31,10 +31,11 @@ export function safeProjectName(name) {
 export function knownProjects(cfg) {
     const out = [];
     const root = (cfg.project?.rootDir ?? '').trim();
-    if (root)
-        out.push({ name: (cfg.project?.name ?? '').trim() || basename(root) || 'project', rootDir: root, isDefault: true, mirror: cfg.project?.mirror ?? EMPTY_SELECTION });
+    if (root) {
+        out.push({ name: (cfg.project?.name ?? '').trim() || basename(root) || 'project', rootDir: root, isDefault: true, mirror: cfg.project?.mirror ?? EMPTY_SELECTION, desktop: cfg.project?.desktop !== false });
+    }
     for (const o of cfg.project?.others ?? [])
-        out.push({ name: o.name, rootDir: o.rootDir, isDefault: false, mirror: o.mirror ?? EMPTY_SELECTION });
+        out.push({ name: o.name, rootDir: o.rootDir, isDefault: false, mirror: o.mirror ?? EMPTY_SELECTION, desktop: o.desktop !== false });
     return out;
 }
 /** What to call the folder for a session's project: its Settings name, else the folder's own. */
@@ -88,26 +89,47 @@ export async function mirrorKnownProject(cfg, project) {
     });
     return { name, rootDir: project.rootDir, targetDir, result };
 }
-/** Every known project, when the switch is on. Nothing when it is off. */
+/**
+ * Every known project that is kept on the Desktop, when the switch is on; nothing when it is off.
+ *
+ * The switch is the master control and each project has its own tick under it. A project whose
+ * tick is off has its Desktop folder removed here, for the same reason the switch going off
+ * removes them all: a stale copy of a code base in the cloud is worse than none.
+ */
 export async function mirrorAllProjects(cfg) {
     if (!cfg.project?.mirrorToDesktop)
         return [];
     await removeLegacyFlatMirror(cfg);
     const out = [];
-    for (const p of knownProjects(cfg))
-        out.push(await mirrorKnownProject(cfg, p));
+    for (const p of knownProjects(cfg)) {
+        // One project whose selection is wrong keeps its old copies and says so; the others are still refreshed.
+        if (p.desktop) {
+            out.push(await mirrorKnownProject(cfg, p).catch((e) => ({
+                name: safeProjectName(p.name),
+                rootDir: p.rootDir,
+                targetDir: projectTargetDir(cfg, p.name),
+                problem: e.message,
+            })));
+        }
+        else
+            await removeProjectFolder(cfg, p);
+    }
     return out;
 }
+async function removeProjectFolder(cfg, p) {
+    const dir = projectTargetDir(cfg, p.name);
+    const info = await stat(dir).catch(() => null);
+    if (!info?.isDirectory())
+        return false;
+    await rm(dir, { recursive: true, force: true });
+    return true;
+}
 /** Removes every known project's folder from the Desktop. The switch going off. */
 export async function removeProjectMirrors(cfg) {
     const removed = [];
     for (const p of knownProjects(cfg)) {
-        const dir = projectTargetDir(cfg, p.name);
-        const info = await stat(dir).catch(() => null);
-        if (!info?.isDirectory())
-            continue;
-        await rm(dir, { recursive: true, force: true });
-        removed.push(dir);
+        if (await removeProjectFolder(cfg, p))
+            removed.push(projectTargetDir(cfg, p.name));
     }
     return removed;
 }

package/dist/src/context/projectMirror.js

@@ -49,6 +49,55 @@ export const DEFAULT_IGNORE_DIRS = [
 ];
 export const DEFAULT_SEPARATOR = '--';
 export const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024;
+/** A selection that cannot be copied as asked. Thrown before the target folder is touched. */
+export class MirrorSelectionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MirrorSelectionError';
+    }
+}
+/**
+ * Each include directory as a path under `rootDir`, looked for in `alsoUnder` when it is not there.
+ *
+ * `found` are the paths to copy; `missing` are the ones that are nowhere, with why. A directory found
+ * in a folder outside `rootDir` is missing too: its files could not be named as the project's.
+ */
+export async function resolveIncludeDirs(rootDir, includeDirs, alsoUnder = []) {
+    const root = resolve(rootDir);
+    const found = [];
+    const moved = [];
+    const missing = [];
+    const isDir = async (p) => !!(await stat(p).catch(() => null))?.isDirectory();
+    for (const dir of includeDirs) {
+        const rel = normalizeDirPath(dir);
+        if (await isDir(join(root, rel))) {
+            found.push(rel);
+            continue;
+        }
+        let reason = `not a folder under the project root ${root}`;
+        let used = null;
+        for (const other of alsoUnder.filter((o) => o.trim() !== '')) {
+            const abs = resolve(other, rel);
+            if (!(await isDir(abs)))
+                continue;
+            const underRoot = relative(root, abs);
+            if (underRoot.startsWith('..') || resolve(root, underRoot) !== abs) {
+                reason = `found under ${resolve(other)}, which is not inside the project root ${root}: make the root that folder`;
+                continue;
+            }
+            used = underRoot.split(osSep).join('/') || '.';
+            break;
+        }
+        if (used) {
+            found.push(used);
+            moved.push({ asked: rel, used });
+        }
+        else {
+            missing.push({ dir: rel, reason });
+        }
+    }
+    return { found, moved, missing };
+}
 /** `.\Src\Foo\` and `src/foo` are the same directory. This is the form both lists compare in. */
 export function normalizeDirPath(dir) {
     const cleaned = dir
@@ -293,7 +342,26 @@ export async function mirrorProject(cfg) {
     const targetDir = resolve(cfg.targetDir);
     const separator = cfg.separator ?? DEFAULT_SEPARATOR;
     const txtMode = cfg.txtMode ?? 'append';
-    const { files, skipped } = await collectFiles(cfg);
+    /*
+     * Checked before the target folder is touched.
+     *
+     * The folder is brought in line with the selection, which deletes whatever the selection does
+     * not hold. A directory that could not be found made the selection empty, and every copy the
+     * chat had been working from was deleted (seen live on 2026-09-30: `rules-engine` not found,
+     * the whole context folder gone, totalBytes 0). A selection that is wrong is now an error that
+     * leaves the copies as they were; so is one that finds no file at all.
+     */
+    const dirs = await resolveIncludeDirs(rootDir, cfg.includeDirs, cfg.alsoUnder);
+    if (dirs.missing.length > 0) {
+        throw new MirrorSelectionError(`The project files could not be copied: ${dirs.missing.map((m) => `"${m.dir}" is ${m.reason}`).join('; ')}. ` +
+            `Nothing was copied, and the copies already in ${targetDir} were left as they are.`);
+    }
+    const { files, skipped } = await collectFiles({ ...cfg, includeDirs: dirs.found });
+    if (files.length === 0) {
+        throw new MirrorSelectionError(`The selection (${cfg.includeDirs.join(', ')}) holds no file that can be copied` +
+            `${skipped.length > 0 ? ` (${skipped.length} skipped, for example ${skipped[0].relPath}: ${skipped[0].reason})` : ''}. ` +
+            `Nothing was copied, and the copies already in ${targetDir} were left as they are.`);
+    }
     await mkdir(targetDir, { recursive: true });
     const used = new Set();
     const desired = new Set();

package/dist/src/orchestrator/contract.js

@@ -28,10 +28,65 @@ async function fileCheckPassesNow(check, cwd) {
     const text = exists ? await readFile(path, 'utf8').catch(() => '') : '';
     return { passes: exists && text.includes(check.value ?? ''), path };
 }
+/** `git` with the global options that may come before its subcommand. */
+const GIT = String.raw `\bgit(?:\s+(?:-C\s+(?:"[^"]*"|'[^']*'|\S+)|--no-pager|-c\s+\S+))*\s+`;
+/** A check whose command asks which branch is checked out. */
+export function readsCurrentBranch(check) {
+    return !!check.run && new RegExp(`${GIT}(?:branch\\s+--show-current|rev-parse\\s+--abbrev-ref\\s+HEAD|symbolic-ref\\s+(?:-q\\s+)?(?:--short\\s+)?HEAD|name-rev\\s+--name-only\\s+HEAD)`, 'i').test(check.run);
+}
+/**
+ * A check whose command asks whether the working tree is clean: `git status --porcelain`/`--short`,
+ * `git diff --quiet`/`--exit-code`. With version control on, the runner commits the task's changes
+ * after its checks — and the chat may not commit — so such a check is decided after that commit.
+ */
+export function readsTreeClean(check) {
+    return !!check.run && new RegExp(`${GIT}(?:status\\b[^|;&\\n]*(?:--porcelain|--short|\\s-s\\b)|diff\\b[^|;&\\n]*(?:--quiet|--exit-code))`, 'i').test(check.run);
+}
+/**
+ * Whether a check about the checked-out branch can pass on `branch`, the one the runner chose.
+ * `null` when it cannot be told without running it.
+ */
+function branchCheckPasses(check, branch) {
+    const value = check.value ?? '';
+    if (check.expect === 'output-contains')
+        return value === '' || branch.includes(value);
+    if (check.expect === 'output-omits')
+        return value === '' || !branch.includes(value);
+    if (check.expect === 'output-matches') {
+        try {
+            return new RegExp(value).test(branch);
+        }
+        catch {
+            return null;
+        }
+    }
+    // A comparison written into the command: `(git branch --show-current) -eq 'recovery/x'`.
+    const named = [...(check.run ?? '').matchAll(/['"]([\w.-]+(?:\/[\w.-]+)+)['"]/g)].map((m) => m[1]);
+    if (named.length > 0)
+        return named.includes(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, 
+/** The branch version control put the task on, when it is on. */
+vcs = {}) {
     const out = [];
     const scope = task.scope ?? [];
+    /*
+     * 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
+     * been started from, while the runner worked on its own. Named before the start, with the check
+     * that does what was meant: that the earlier work is in this branch.
+     */
+    if (vcs.branch) {
+        const all = [...(task.checks ?? []), ...(task.reviewChecks ?? []).filter((rc) => rc.state === 'active').map((rc) => rc.check)];
+        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.');
+        }
+    }
     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.`);
     }