copilot-operator 0.1.11 → 0.1.13

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);
     }
     /**

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

@@ -19,7 +19,7 @@ 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';
@@ -38,7 +38,7 @@ function sameFolder(a, b) {
 import { importPlan, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
 import { readInterruption } from '../session/interruption.js';
 import { commitInterrupted, repoDirOf, vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
-import { changedFilesBetween, fileAt, gitAvailable, repoUnusableReason } from '../vcs/git.js';
+import { branchExists, changedFilesBetween, fileAt, gitAvailable, localBranches, plannedBranchName, repoUnusableReason } from '../vcs/git.js';
 import { makeAuthorizer } from '../exec/authorizer.js';
 import { listSelectableDirs, collectFiles, findSelectionConflicts, describeConflicts, DEFAULT_IGNORE_DIRS } from '../context/projectMirror.js';
 import { pickFolder } from './folderPicker.js';
@@ -235,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".
@@ -270,6 +277,8 @@ let OperatorService = class OperatorService {
                 }
                 if (merged.baseBranch !== undefined)
                     merged.baseBranch = merged.baseBranch.trim();
+                if (merged.existingBranch !== undefined)
+                    merged.existingBranch = merged.existingBranch.trim();
                 /*
                  * Where the session starts is fixed at its first run. A new choice clears that record, so
                  * the next task to run is cut from what was chosen now; the tasks that already ran keep
@@ -277,6 +286,8 @@ let OperatorService = class OperatorService {
                  */
                 const startChanged = (merged.startFrom ?? 'head') !== (s.vcs?.startFrom ?? 'head') ||
                     (merged.baseBranch || 'main') !== (s.vcs?.baseBranch || 'main') ||
+                    (merged.existingBranch ?? '') !== (s.vcs?.existingBranch ?? '') ||
+                    (merged.updateFromRemote !== false) !== (s.vcs?.updateFromRemote !== false) ||
                     merged.repoDir.toLowerCase() !== (s.vcs?.repoDir ?? '').trim().toLowerCase();
                 if (startChanged) {
                     s.vcsBaseCommit = undefined;
@@ -324,7 +335,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);
@@ -749,6 +760,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) };
@@ -804,6 +819,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,
@@ -1348,6 +1365,31 @@ let OperatorService = class OperatorService {
                 });
             }
         });
+        if (repoIssues.length > 0)
+            return { ok: false, issues: repoIssues, warnings: check.warnings, duplicates: [] };
+        /*
+         * A branch to carry on must be there to carry on — unless a session before it in this same plan
+         * is the one that makes it. Refused now, with the branches that are there, rather than at the
+         * first run with a task refused.
+         */
+        for (const [i, session] of check.plan.sessions.entries()) {
+            const wanted = session.vcs?.enabled === false ? '' : (session.vcs?.existingBranch ?? '').trim();
+            if (!wanted)
+                continue;
+            const dir = session.vcs?.repoDir?.trim() || session.mirror?.rootDir?.trim() || '';
+            const madeEarlier = check.plan.sessions
+                .slice(0, i)
+                .some((e) => !!e.vcs?.branchName?.trim() && plannedBranchName(e.vcs.branchName, e.vcs.branchPrefix?.trim() || 'cop/') === wanted);
+            if (madeEarlier || (await branchExists(dir, wanted)))
+                continue;
+            const have = await localBranches(dir);
+            repoIssues.push({
+                path: `sessions[${i}].vcs.existingBranch`,
+                message: `${dir} has no local branch "${wanted}" to carry on. ` +
+                    (have.length > 0 ? `Its branches: ${have.slice(0, 20).join(', ')}.` : 'It has no branches yet.') +
+                    ' Give the exact name, or use startFrom "branch" to start a new one.',
+            });
+        }
         if (repoIssues.length > 0)
             return { ok: false, issues: repoIssues, warnings: check.warnings, duplicates: [] };
         return { ...check, duplicates: await this.findDuplicates(check.plan) };
@@ -1540,7 +1582,10 @@ let OperatorService = class OperatorService {
             return { ok: false, repoDir: '', problem: "git is not installed, or not on this machine's PATH.", git: null };
         // `branch` is where HEAD is; `work` is where the session's work is. After a per-task run
         // those differ, and the second is the one the operator is asking about.
-        return { ...(await vcsPreflight(session)), git, work: sessionBranches(session) };
+        const preflight = await vcsPreflight(session);
+        // The local branches, so "carry on an existing branch" can offer them rather than be typed blind.
+        const branches = preflight.repoDir ? await localBranches(preflight.repoDir) : [];
+        return { ...preflight, git, work: sessionBranches(session), branches };
     }
     /**
      * What going back to before a task would do, and then doing it.
@@ -1814,7 +1859,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,
@@ -1823,10 +1868,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
@@ -1841,8 +1918,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) {
@@ -1871,6 +1948,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) {
@@ -1889,7 +1968,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
@@ -2054,6 +2138,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({}),
     /**

package/dist/src/context/desktopMirror.js

@@ -14,7 +14,7 @@
  * `project.mirrorToDesktop`; a session's own mirror (the files attached to its first message)
  * uses the same folder for its project whether or not the switch is on.
  */
-import { basename, join, resolve } from 'node:path';
+import { basename, join, resolve, relative, isAbsolute } from 'node:path';
 import { readdir, rm, stat } from 'node:fs/promises';
 import { mirrorProject } from './projectMirror.js';
 import { defaultExportDir } from './contextFiles.js';
@@ -31,12 +31,51 @@ 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;
 }
+/**
+ * Whether the Desktop copy of the project at `rootDir` is kept by "Keep the projects on the Desktop".
+ *
+ * Then its Desktop folder has one owner, the Desktop mirror, and a task's attachments are copied
+ * elsewhere. The two used to share it with different selections — the whole project there, the
+ * task's folders here — so every run deleted most of the folder and every round of steps put it
+ * back: thousands of deletions and uploads in a OneDrive-synced Desktop, while the chat was
+ * uploading the task's own attachments to the same OneDrive (2026-09-30, a first message timing out).
+ */
+export function keptOnDesktop(cfg, rootDir) {
+    return !!cfg.project?.mirrorToDesktop && knownProjects(cfg).some((p) => p.desktop && sameFolder(p.rootDir, rootDir));
+}
+/**
+ * The project folder to copy from, for a folder a session names as its project files' root.
+ *
+ * A folder in the bot's own Desktop area (`contextRoot`) is not a project: it is the bot's copy of
+ * one, flattened, and the place the copies are written to. Named as a root — seen live on 2026-09-30,
+ * `...\Desktop\copilot-operator-context\Automation` — the mirror read the folder it was writing: with
+ * "Keep the projects on the Desktop" on it copied its own copies over the originals while the Desktop
+ * mirror put them back, and the first message timed out; with it off the folder was not there and
+ * the task was refused. Such a folder is taken to mean the project it is the copy of; one that is the
+ * copy of no known project is refused, with what to choose instead.
+ */
+export function mirrorSourceRoot(cfg, rootDir) {
+    const area = resolve(contextRoot(cfg));
+    const dir = resolve(rootDir);
+    const rel = relative(area, dir);
+    if (rel === '') {
+        return { problem: `${dir} is the folder where the bot keeps its Desktop copies, not a project. Choose the project's own folder as the root of the files to attach.` };
+    }
+    if (rel.startsWith('..') || isAbsolute(rel))
+        return { rootDir };
+    const copyOf = knownProjects(cfg).find((p) => sameFolder(projectTargetDir(cfg, p.name), join(area, rel.split(/[\\/]/)[0])));
+    if (!copyOf) {
+        return { problem: `${dir} is inside the folder where the bot keeps its Desktop copies (${area}), not a project, and it is not the copy of any project on the Project page. Choose the project's own folder as the root of the files to attach.` };
+    }
+    return { rootDir: copyOf.rootDir, fromCopy: dir };
+}
 /** What to call the folder for a session's project: its Settings name, else the folder's own. */
 export function projectNameFor(rootDir, cfg) {
     const known = knownProjects(cfg).find((p) => sameFolder(p.rootDir, rootDir));
@@ -88,26 +127,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.`);
     }