copilot-operator 0.1.12 → 0.1.15

package/dist/src/session/store.js

@@ -4,10 +4,12 @@
  * JSON files, not a database. A single operator on one machine gets nothing from a
  * database except a dependency, and files can be read, diffed and backed up with nothing
  * installed. Writes go through a temp file and a rename, so a crash mid-write cannot leave a
- * half-written session behind.
+ * half-written session behind, and the writes of one file wait their turn (see `inTurn`), so two
+ * at once cannot fail each other or undo each other's change.
  */
 import { mkdir, readFile, writeFile, readdir, rename, rm } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { join, resolve } from 'node:path';
 import { isContinuable, newId, tidyVcsPlan } from './model.js';
 /** A task the runner is inside of. It cannot be edited, deleted, or left behind at startup. */
@@ -34,14 +36,27 @@ export const DEFAULT_VCS = {
     commitOnFinish: true,
     branchPrefix: 'cop/',
 };
-export const DEFAULT_MIRROR = {
-    enabled: false,
-    rootDir: '',
-    includeDirs: [],
-    excludeDirs: [],
-    respectGitignore: true,
-    includeEnvFiles: false,
-};
+/**
+ * Points a new session that names no folder at the default project, the one on the Project page.
+ *
+ * The one rule for every way a session is made: on the Sessions page and by importing a plan. The
+ * import used to skip it, so a plan's session with version control off and no `projectDir` — the
+ * brief's own example has one — kept an empty folder and ran its commands in `execution.cwd`,
+ * somewhere the operator never chose, while the same session made by hand worked in their project.
+ *
+ * Both fields, because they answer different questions about the same folder: where the work is
+ * and where the branches go. Version control is not switched on by being filled in. A session that
+ * names either keeps what it named and gets nothing here: a plan's repository with the default
+ * project beside it as its folder would say the work is in two places.
+ */
+export function applyDefaultProject(session, defaultDir) {
+    const dir = defaultDir.trim();
+    if (!dir || session.projectDir.trim() || session.vcs?.repoDir.trim())
+        return;
+    session.projectDir = dir;
+    if (session.vcs)
+        session.vcs.repoDir = dir;
+}
 /**
  * Applies an edit to a task: the one place the rule about a new intent lives.
  *
@@ -114,10 +129,10 @@ export class SessionStore {
         return { content: await readFile(this.defaultLevel1Path, 'utf8'), customised: false };
     }
     async setLevel1(content) {
-        await this.atomicWrite(this.level1Path, content);
+        await writeFileAtomically(this.level1Path, content);
     }
     async resetLevel1() {
-        await rm(this.level1Path, { force: true });
+        await removeFile(this.level1Path);
     }
     // --- the organisation's part of the plan persona -------------------------------------
     /**
@@ -136,10 +151,10 @@ export class SessionStore {
         return { content: '', customised: false, example };
     }
     async setContext(kind, content) {
-        await this.atomicWrite(join(this.dir, `context-${kind}.md`), content);
+        await writeFileAtomically(join(this.dir, `context-${kind}.md`), content);
     }
     async resetContext(kind) {
-        await rm(join(this.dir, `context-${kind}.md`), { force: true });
+        await removeFile(join(this.dir, `context-${kind}.md`));
     }
     // --- the model catalogue ----------------------------------------------------------------
     /** What the chat's picker offered when it was last read, or null if it never was. */
@@ -152,7 +167,7 @@ export class SessionStore {
         }
     }
     async saveModels(catalogue) {
-        await this.atomicWrite(this.modelsPath, JSON.stringify(catalogue, null, 2));
+        await writeFileAtomically(this.modelsPath, JSON.stringify(catalogue, null, 2));
     }
     // --- level 2 presets ------------------------------------------------------------------
     async listPresets() {
@@ -168,15 +183,23 @@ export class SessionStore {
         }
         return out;
     }
+    /**
+     * Saves a preset under the name it can later be deleted by.
+     *
+     * Stripping the characters a file name cannot hold is not enough on its own: a leading dot and
+     * ".." survive it, and `safePresetName` refuses both, so ".env" and "a..b" were saved and then
+     * could never be deleted. The name goes through the same rule as the delete, the way a persona's
+     * always has, so a name that could not be removed is refused here instead.
+     */
     async savePreset(name, content) {
         const safe = name.replace(/[^\p{L}\p{N}._ -]/gu, '').trim();
         if (!safe)
             throw new Error('Preset name is empty after removing unsafe characters.');
-        await this.atomicWrite(join(this.presetsDir, `${safe}.md`), content);
+        await writeFileAtomically(join(this.presetsDir, `${safePresetName(safe)}.md`), content);
         return { name: safe, content, updatedAt: new Date().toISOString() };
     }
     async deletePreset(name) {
-        await rm(join(this.presetsDir, `${safePresetName(name)}.md`), { force: true });
+        await removeFile(await namedFile(this.presetsDir, name));
     }
     // --- named personas -------------------------------------------------------------------
     //
@@ -202,11 +225,11 @@ export class SessionStore {
         if (!safe)
             throw new Error('The persona name is empty after removing unsafe characters.');
         await mkdir(this.personasDir, { recursive: true });
-        await this.atomicWrite(join(this.personasDir, `${safePresetName(safe)}.md`), content);
+        await writeFileAtomically(join(this.personasDir, `${safePresetName(safe)}.md`), content);
         return { name: safe, content, updatedAt: new Date().toISOString() };
     }
     async deletePersona(name) {
-        await rm(join(this.personasDir, `${safePresetName(name)}.md`), { force: true });
+        await removeFile(await namedFile(this.personasDir, name));
     }
     // --- sessions -------------------------------------------------------------------------
     /**
@@ -238,10 +261,27 @@ export class SessionStore {
             return b.id.localeCompare(a.id);
         });
     }
+    /**
+     * The session of this id, or null when there is none.
+     *
+     * An id that could not be a session's file name — a path, `..`, anything `safeName` refuses —
+     * names no session, and is answered as one that does not exist. It used to throw here, so every
+     * route that only reads a session (the session itself, a task's log, story or files, a start)
+     * answered a path for an id with a 500 rather than the 404 or "no such session" a missing one
+     * gets. A write or a delete of such an id is still refused outright: those go through
+     * `sessionPath` themselves.
+     */
     async getSession(id) {
-        return await this.readSession(join(this.sessionsDir, `${safeName(id)}.json`));
+        let path;
+        try {
+            path = this.sessionPath(id);
+        }
+        catch {
+            return null;
+        }
+        return await this.readSession(path);
     }
-    async createSession(name, mirror = {}) {
+    async createSession(name, projectDir = '') {
         const session = {
             id: newId(),
             name: name.trim() || 'untitled',
@@ -252,26 +292,38 @@ export class SessionStore {
             // behaved and the safer of the two.
             onFailure: 'stop',
             vcs: { ...DEFAULT_VCS },
-            mirror: { ...DEFAULT_MIRROR, ...mirror },
+            projectDir: projectDir.trim(),
             tasks: [],
         };
         await this.saveSession(session);
         return session;
     }
     async saveSession(session) {
-        await this.atomicWrite(join(this.sessionsDir, `${safeName(session.id)}.json`), JSON.stringify(session, null, 2));
+        await writeFileAtomically(this.sessionPath(session.id), JSON.stringify(session, null, 2));
     }
     async deleteSession(id) {
-        await rm(join(this.sessionsDir, `${safeName(id)}.json`), { force: true });
+        await removeFile(this.sessionPath(id));
     }
-    /** Applies a change under a fresh read, so two writers cannot clobber each other. */
+    /**
+     * Applies a change under a fresh read, so two writers cannot clobber each other.
+     *
+     * The read, the change and the write happen in the file's turn, with nothing else of this
+     * process writing the session in between. A fresh read alone did not keep that promise: Stop
+     * writes "stopping" at the moment it answers an approval, and the runner it has just woken
+     * writes the task at the same moment. Both read the session before either had written, so
+     * whichever wrote second put back what the first had changed, or, when both renamed at once,
+     * one of them failed and took the stop or the task down with it.
+     */
     async updateSession(id, mutate) {
-        const s = await this.getSession(id);
-        if (!s)
-            throw new Error(`Session ${id} does not exist.`);
-        mutate(s);
-        await this.saveSession(s);
-        return s;
+        const path = this.sessionPath(id);
+        return await inTurn(path, async () => {
+            const s = await this.readSession(path);
+            if (!s)
+                throw new Error(`Session ${id} does not exist.`);
+            mutate(s);
+            await replaceFile(path, JSON.stringify(s, null, 2));
+            return s;
+        });
     }
     async addTask(sessionId, input) {
         const vcsPlan = tidyVcsPlan(input.vcsPlan);
@@ -465,33 +517,41 @@ export class SessionStore {
      */
     async recoverInterrupted() {
         const recovered = [];
-        for (const session of await this.listSessions()) {
-            const stuck = session.tasks.filter((t) => ACTIVE_STATUSES.includes(t.status));
-            const busySession = session.status !== 'idle';
-            if (stuck.length === 0 && !busySession)
+        for (const listed of await this.listSessions()) {
+            if (listed.status === 'idle' && !listed.tasks.some((t) => ACTIVE_STATUSES.includes(t.status)))
                 continue;
-            for (const t of stuck) {
-                t.status = 'aborted';
-                t.finishedAt = t.finishedAt ?? new Date().toISOString();
-                t.reason =
-                    'The bot stopped while this task was in progress (the program was closed, the machine went off, or it crashed), so it never finished. ' +
-                        'Its work so far is kept; "Continue in the same chat" carries it on where it stopped.';
-                recovered.push({ sessionId: session.id, taskId: t.id, title: t.title });
-            }
-            session.status = 'idle';
-            await this.saveSession(session);
+            // Read again in the file's turn, like any other change, so a write that landed since the
+            // list was read is kept rather than replaced by the copy in the list.
+            const path = this.sessionPath(listed.id);
+            await inTurn(path, async () => {
+                const session = await this.readSession(path);
+                if (!session)
+                    return;
+                for (const t of session.tasks.filter((x) => ACTIVE_STATUSES.includes(x.status))) {
+                    t.status = 'aborted';
+                    t.finishedAt = t.finishedAt ?? new Date().toISOString();
+                    t.reason =
+                        'The bot stopped while this task was in progress (the program was closed, the machine went off, or it crashed), so it never finished. ' +
+                            'Its work so far is kept; "Continue in the same chat" carries it on where it stopped.';
+                    recovered.push({ sessionId: session.id, taskId: t.id, title: t.title });
+                }
+                session.status = 'idle';
+                await replaceFile(path, JSON.stringify(session, null, 2));
+            });
         }
         return recovered;
     }
     // --- helpers --------------------------------------------------------------------------
     /**
-     * Reads one session file, filling in mirror fields added after it was written. Sessions are
+     * Reads one session file, filling in fields added after it was written. Sessions are
      * long-lived JSON on disk, so a new option must never come back as `undefined`.
      */
     async readSession(path) {
         try {
             const s = JSON.parse(await readFile(path, 'utf8'));
-            s.mirror = { ...DEFAULT_MIRROR, ...(s.mirror ?? {}) };
+            // Written before the project-files feature was removed: its root is the project folder.
+            s.projectDir = (s.projectDir ?? s.mirror?.rootDir ?? '').trim();
+            delete s.mirror;
             s.vcs = { ...DEFAULT_VCS, ...(s.vcs ?? {}) };
             // Sessions written before the queue could be told what to do on a failure behave the
             // way they always did: the chain stops.
@@ -502,44 +562,119 @@ export class SessionStore {
             return null;
         }
     }
-    /**
-     * Write through a temp file and a rename, and keep trying when Windows says no.
-     *
-     * The rename is what makes the write atomic: a crash halfway through leaves the temp file
-     * behind and the real one untouched. On Windows it is also the step that fails, because
-     * renaming onto a destination that any other process has open is refused outright — and this
-     * file is read constantly, by the register polling every few seconds, by the sessions list,
-     * and by whatever virus scanner has decided to look inside a JSON file that just changed.
-     *
-     * The failure is EPERM and it is transient: the handle closes microseconds later. Letting it
-     * through unretried meant a task dying mid-run with a message about a temp file, which is
-     * what happened — a scaffold that had finished three tasks was killed by a file lock on the
-     * fourth. So it is retried, briefly and with a growing pause, and only then given up on.
-     */
-    async atomicWrite(path, content) {
-        const tmp = `${path}.${process.pid}.tmp`;
-        await writeFile(tmp, content, 'utf8');
-        const backoffMs = [10, 25, 60, 120, 250, 500];
-        for (let attempt = 0;; attempt += 1) {
-            try {
-                await rename(tmp, path);
-                return;
-            }
-            catch (e) {
-                const code = e.code ?? '';
-                const transient = code === 'EPERM' || code === 'EACCES' || code === 'EBUSY';
-                if (!transient || attempt >= backoffMs.length) {
-                    // The temp file is no use to anyone now, and leaving one per failed write behind
-                    // would slowly fill the folder with them.
-                    await rm(tmp, { force: true }).catch(() => undefined);
-                    throw new Error(`Could not save ${path}: ${code || e.message}. ` +
-                        'Something else is holding the file open — an editor, a sync client or a virus scanner.');
-                }
-                await new Promise((r) => setTimeout(r, backoffMs[attempt]));
+    sessionPath(id) {
+        return join(this.sessionsDir, `${safeName(id)}.json`);
+    }
+}
+// --- writing a file -------------------------------------------------------------------------
+/**
+ * The work queued on each file, by the file's full path: the tail of its chain.
+ *
+ * Kept for the module, not for one store, because every store in a process writes the same
+ * files: the API has one, but a check or the terminal may make another over the same folder,
+ * and a queue each would let their writes meet again.
+ */
+const queued = new Map();
+/**
+ * Runs `work` once everything queued earlier on the same file has finished, failed or not.
+ *
+ * Every write of the store goes through here, and `updateSession` holds the turn across its read
+ * as well, as does a write worked out from the file (see `writeFileAtomically`), so a change is
+ * always made to what the last write left. `work` must not wait for another turn on the same file,
+ * which would wait for itself; nothing here does, and a session's `mutate` is synchronous, so it
+ * cannot.
+ *
+ * In this process only: another process writing the same file at the same time is not waited
+ * for. The one that might, a run from the terminal, makes a session of its own and writes only that.
+ */
+function inTurn(path, work) {
+    const full = resolve(path);
+    // Windows treats `A.json` and `a.json` as one file, so they share one queue there.
+    const key = process.platform === 'win32' ? full.toLowerCase() : full;
+    const run = (queued.get(key) ?? Promise.resolve()).then(work);
+    const tail = run.then(() => undefined, () => undefined);
+    queued.set(key, tail);
+    // Forgotten once nothing is queued behind it, so the map holds only the files being written.
+    void tail.then(() => {
+        if (queued.get(key) === tail)
+            queued.delete(key);
+    });
+    return run;
+}
+/**
+ * Writes a file whole, in its turn: a crash, or another write of the same file, cannot leave it
+ * half written or lose either write. For any file the program keeps, not only the store's.
+ *
+ * `content` may be a function instead, for a write worked out from what the file holds: it is
+ * called in the file's turn, so what it reads is what the last write left, and nothing else of this
+ * process writes the file until its answer has landed. Read first and written here, a change of one
+ * setting put back whatever another had changed in between. If it throws, nothing is written. Like
+ * any work in a turn, it must not wait for another turn on the same file (see `inTurn`).
+ */
+export async function writeFileAtomically(path, content) {
+    await inTurn(path, async () => replaceFile(path, typeof content === 'string' ? content : await content()));
+}
+/** Removes a file in its turn, so a delete and a write of it land in the order they were asked for. */
+async function removeFile(path) {
+    await inTurn(path, () => rm(path, { force: true }));
+}
+/**
+ * Write through a temp file and a rename, and keep trying when Windows says no. Not queued: the
+ * caller holds the file's turn (see `inTurn`).
+ *
+ * The rename is what makes the write atomic: a crash halfway through leaves the temp file
+ * behind and the real one untouched. On Windows it is also the step that fails, because
+ * renaming onto a destination that any other process has open is refused outright — and this
+ * file is read constantly, by the register polling every few seconds, by the sessions list,
+ * and by whatever virus scanner has decided to look inside a JSON file that just changed.
+ *
+ * The failure is EPERM and it is transient: the handle closes microseconds later. Letting it
+ * through unretried meant a task dying mid-run with a message about a temp file, which is
+ * what happened — a scaffold that had finished three tasks was killed by a file lock on the
+ * fourth. So it is retried, briefly and with a growing pause, and only then given up on.
+ *
+ * Each write has a temp file of its own. One name per process was shared by every write of the
+ * same file, so when two overlapped, the first rename took the temp file the second was about to
+ * rename, and the second failed with ENOENT — reported as a lock it was not.
+ */
+async function replaceFile(path, content) {
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tmp, content, 'utf8');
+    const backoffMs = [10, 25, 60, 120, 250, 500];
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            await rename(tmp, path);
+            return;
+        }
+        catch (e) {
+            const code = e.code ?? '';
+            const transient = code === 'EPERM' || code === 'EACCES' || code === 'EBUSY';
+            if (!transient || attempt >= backoffMs.length) {
+                // The temp file is no use to anyone now, and leaving one per failed write behind
+                // would slowly fill the folder with them.
+                await rm(tmp, { force: true }).catch(() => undefined);
+                throw new Error(transient
+                    ? `Could not save ${path}: ${code}. Something else is holding the file open — an editor, a sync client or a virus scanner.`
+                    : `Could not save ${path}: ${e.message}`);
             }
+            await new Promise((r) => setTimeout(r, backoffMs[attempt]));
         }
     }
 }
+/**
+ * The file a preset or persona of this name is kept in, for removing it.
+ *
+ * A name `safePresetName` accepts, or one that is already a file in the folder. The save did not
+ * always apply that rule, so a preset called ".env" or "a..b" may be on disk from before; without
+ * the second way it is listed and can never be deleted. A name matched against the folder's own
+ * listing is a file name, which cannot hold a separator, so it cannot reach outside the folder.
+ */
+async function namedFile(dir, name) {
+    const onDisk = await readdir(dir).catch(() => []);
+    if (onDisk.includes(`${name}.md`))
+        return join(dir, `${name}.md`);
+    return join(dir, `${safePresetName(name)}.md`);
+}
 /**
  * A session id as it may appear in a file name, or an error.
  *

package/dist/src/vcs/git.js

@@ -44,9 +44,9 @@ function noHooksDir() {
     return process.env.SystemRoot ? join(process.env.SystemRoot, 'System32', 'copilot-operator-no-hooks') : '/nonexistent';
 }
 /** Runs one git command in a directory. Never throws: the caller decides what a failure means. */
-export function git(cwd, args, timeoutMs = 60_000) {
+export function git(cwd, args, timeoutMs = 60_000, env) {
     return new Promise((resolve) => {
-        execFile('git', [...SAFE_GIT, ...args], { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }, (error, stdout, stderr) => {
+        execFile('git', [...SAFE_GIT, ...args], { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 8 * 1024 * 1024, ...(env ? { env } : {}) }, (error, stdout, stderr) => {
             const code = error?.code;
             resolve({
                 ok: !error,
@@ -178,6 +178,81 @@ export async function isValidBranchName(dir, name) {
     const r = await git(dir, ['check-ref-format', '--branch', name]);
     return r.ok;
 }
+/**
+ * Brings a local branch up to date with its remote: `git fetch`, then a fast-forward and nothing else.
+ *
+ * Asked for on 2026-09-30, so a session's branch is cut from the code as it is on the server and not
+ * from whatever this checkout last pulled. Never a reset, a merge commit or a rewrite: a branch with
+ * commits of its own (ahead) or one that has gone its own way (diverged) is left as it is, and the
+ * outcome says so. The remote is the branch's upstream, or `origin` when it has none; a repository
+ * with neither is left alone. git is not allowed to ask for credentials — a prompt would hang the run,
+ * and a sign-in window on a machine nobody is watching is worse — so a remote that needs a password
+ * git does not already have fails the fetch, which is reported, not fatal.
+ */
+export async function updateFromRemote(dir, branch) {
+    const local = await git(dir, ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}^{commit}`]);
+    if (!local.ok || !local.stdout)
+        return { branch, outcome: 'failed', detail: `there is no local branch ${branch}` };
+    const upstream = await git(dir, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', `${branch}@{upstream}`]);
+    let remote = '';
+    let remoteBranch = branch;
+    if (upstream.ok && upstream.stdout.includes('/')) {
+        remote = upstream.stdout.slice(0, upstream.stdout.indexOf('/'));
+        remoteBranch = upstream.stdout.slice(remote.length + 1);
+    }
+    else {
+        const remotes = await git(dir, ['remote']);
+        const names = remotes.ok ? remotes.stdout.split(/\r?\n/).map((r) => r.trim()).filter(Boolean) : [];
+        if (names.includes('origin'))
+            remote = 'origin';
+    }
+    if (!remote)
+        return { branch, outcome: 'no-remote', detail: 'the repository has no remote to update from' };
+    const tracking = `${remote}/${remoteBranch}`;
+    const quiet = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never', GIT_ASKPASS: '', SSH_ASKPASS: '' };
+    const fetched = await git(dir, ['-c', 'credential.interactive=false', 'fetch', '--quiet', '--no-tags', remote, `+refs/heads/${remoteBranch}:refs/remotes/${tracking}`], 90_000, quiet);
+    if (!fetched.ok) {
+        return { branch, remote: tracking, outcome: 'fetch-failed', detail: (fetched.stderr || fetched.stdout || 'git fetch failed').split(/\r?\n/)[0] };
+    }
+    const theirs = await git(dir, ['rev-parse', '--verify', '--quiet', `refs/remotes/${tracking}^{commit}`]);
+    if (!theirs.ok || !theirs.stdout)
+        return { branch, remote: tracking, outcome: 'no-remote', detail: `${tracking} does not exist on the remote` };
+    const from = local.stdout;
+    const to = theirs.stdout;
+    if (from === to)
+        return { branch, remote: tracking, outcome: 'up-to-date', from, to };
+    if (await isAncestor(dir, to, from))
+        return { branch, remote: tracking, outcome: 'ahead', from, to, detail: `${branch} has commits ${tracking} does not; it was left as it is` };
+    if (!(await isAncestor(dir, from, to))) {
+        return { branch, remote: tracking, outcome: 'diverged', from, to, detail: `${branch} and ${tracking} have each gone their own way; ${branch} was left as it is` };
+    }
+    // Forward only. A branch that is checked out moves with its tree (clean, or the caller would not be
+    // here); one that is not is moved by its ref, and only if it still is where it was read.
+    const current = await git(dir, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    const moved = current.ok && current.stdout === branch
+        ? await git(dir, ['merge', '--ff-only', '--quiet', to])
+        : await git(dir, ['update-ref', `refs/heads/${branch}`, to, from]);
+    if (!moved.ok)
+        return { branch, remote: tracking, outcome: 'failed', from, to, detail: (moved.stderr || moved.stdout).split(/\r?\n/)[0] };
+    return { branch, remote: tracking, outcome: 'updated', from, to };
+}
+/** One line for the log and the session page. */
+export function describeUpdate(u) {
+    const short = (c) => (c ? c.slice(0, 8) : '?');
+    switch (u.outcome) {
+        case 'updated':
+            return `${u.branch} brought up to date with ${u.remote}: ${short(u.from)} → ${short(u.to)}`;
+        case 'up-to-date':
+            return `${u.branch} was already up to date with ${u.remote}`;
+        default:
+            return `${u.branch} not updated from the remote: ${u.detail ?? u.outcome}`;
+    }
+}
+/** The local branches of a repository, by name; empty when it cannot be read. */
+export async function localBranches(dir) {
+    const r = await git(dir, ['for-each-ref', '--format=%(refname:short)', 'refs/heads']);
+    return r.ok ? r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean) : [];
+}
 export async function branchExists(dir, name) {
     const r = await git(dir, ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`]);
     return r.ok && r.stdout.length > 0;

package/dist/src/vcs/scope.js

@@ -15,13 +15,27 @@
  *
  * Patterns are repository-relative and use `/`: `tests/e2e/editor.spec.ts` is one file,
  * `tests/e2e/` or `tests/e2e/**` is everything under that folder, `*` matches within one folder
- * and `**` across folders. Matching ignores case, as Windows does.
+ * and `**` across folders. A pattern is read the way a path is: `\` is `/`, a `./` or `/` in front
+ * and a `//` or `/./` inside change nothing, `src/../docs` is `docs`, and `.`, `./` or `/` alone is
+ * the whole repository. Matching ignores case, as Windows does.
  */
 import { readdir, rm, rmdir } from 'node:fs/promises';
-import { dirname, join, resolve, sep } from 'node:path';
+import { dirname, join, posix, resolve, sep } from 'node:path';
 import { git, workingTreePaths } from './git.js';
+/**
+ * A path or pattern in the one spelling the matching expects: `/` between folders, nothing in front,
+ * and no empty, `.` or `..` folder anywhere in it. A plan writes the same folder as `docs`, `./docs`,
+ * `/docs`, `.\docs` or `src/../docs`, and they must all cover the same files: each spelling the
+ * matching did not expect covered nothing, so every change the task made under it was put back.
+ * Cleaning only the front left `src//docs` and `docs/.` the same way, so the whole path is resolved
+ * here, as a path would be. The repository itself (`.`, `./`, `/`) comes out as the empty string.
+ */
+function normalise(p) {
+    const n = posix.normalize(p.replace(/\\/g, '/')).replace(/^\/+/, '');
+    return n === '.' || n === './' ? '' : n;
+}
 function toRegExp(pattern) {
-    let p = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+    let p = normalise(pattern.trim());
     // A folder, written with or without `**`, is everything under it.
     if (p.endsWith('/'))
         p += '**';
@@ -52,11 +66,20 @@ function toRegExp(pattern) {
 export function inScope(path, scope) {
     if (scope.length === 0)
         return true;
-    const p = path.replace(/\\/g, '/').replace(/^\.\//, '');
+    const p = normalise(path);
     return scope.some((pattern) => {
-        const clean = pattern.trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+        // A blank entry names nothing, so it covers nothing. It must not read as the repository below,
+        // which it would, since normalising it gives the same empty string as `.` does.
+        if (pattern.trim() === '')
+            return false;
+        const clean = normalise(pattern.trim()).replace(/\/+$/, '');
+        // `.`, `./` or `/` is the repository itself, so the whole project: a plan writes it to mean
+        // anywhere, and read as a file named `.`, or as no path at all, it covered nothing and every
+        // change the task made was put back.
+        if (clean === '')
+            return true;
         // A plain folder name without a slash still means the folder: `pages` covers `pages/Home.ts`.
-        if (clean && !/[*?]/.test(clean) && p.toLowerCase().startsWith(`${clean.toLowerCase()}/`))
+        if (!/[*?]/.test(clean) && p.toLowerCase().startsWith(`${clean.toLowerCase()}/`))
             return true;
         return toRegExp(pattern).test(p);
     });