copilot-operator 0.1.12 → 0.1.13

package/dist/src/api/operator.service.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';
@@ -277,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
@@ -284,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;
@@ -1361,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) };
@@ -1553,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.

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';
@@ -38,6 +38,44 @@ export function knownProjects(cfg) {
         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));

package/dist/src/orchestrator/taskRunner.js

@@ -45,7 +45,7 @@ import { ProgressWatch } from './progress.js';
 import { contractConflicts, readsTreeClean } from './contract.js';
 import { treeFingerprint } from '../vcs/git.js';
 import { mirrorProject, describeMirror, MirrorSelectionError } from '../context/projectMirror.js';
-import { projectNameFor, projectTargetDir, removeLegacyFlatMirror } from '../context/desktopMirror.js';
+import { keptOnDesktop, mirrorSourceRoot, projectNameFor, projectTargetDir, removeLegacyFlatMirror } from '../context/desktopMirror.js';
 import { prepareForTask, commitTaskResult, repoDirOf } from '../vcs/taskVcs.js';
 import { exportMachine, writeAttemptRecord } from '../session/exports.js';
 /** Why a task that was reported as done is being closed as failed. */
@@ -670,6 +670,12 @@ export async function runTask(transport, session, task, deps) {
         const prepared = await prepareForTask(session, task, bus, async (mutate) => {
             await store.updateSession(session.id, mutate);
         }, () => store.listSessions());
+        if (prepared.refuse) {
+            await setTask((t) => {
+                t.vcs = prepared.vcs;
+            });
+            return await finish('failed', prepared.refuse);
+        }
         if (prepared.vcs.branch || prepared.vcs.problem) {
             await setTask((t) => {
                 t.vcs = prepared.vcs;
@@ -716,15 +722,28 @@ export async function runTask(transport, session, task, deps) {
         if (session.mirror.enabled && session.mirror.rootDir) {
             // One folder per project, and the project's name in front of every file name, so three
             // repositories mirrored in turn do not delete each other's copies or collide in the chat.
-            const projectName = projectNameFor(session.mirror.rootDir, cfg);
-            const targetDir = projectTargetDir(cfg, projectName);
+            // The bot's own Desktop copy named as the root means the project it is a copy of. See `mirrorSourceRoot`.
+            const source = mirrorSourceRoot(cfg, session.mirror.rootDir);
+            if ('problem' in source) {
+                sink.event('mirror-refused', { error: source.problem }, source.problem, 'error');
+                return await finish('failed', `${source.problem} Nothing was sent to the chat.`);
+            }
+            if (source.fromCopy) {
+                sink.event('mirror-source', { asked: source.fromCopy, used: source.rootDir }, `the root of the files to attach is the bot's Desktop copy ${source.fromCopy}; they are copied from the project itself, ${source.rootDir}`, 'warn');
+            }
+            const sourceRoot = source.rootDir;
+            const projectName = projectNameFor(sourceRoot, cfg);
+            // A project kept on the Desktop has its folder there looked after by the Desktop mirror; the
+            // attachments are copied into this attempt's own folder instead. See `keptOnDesktop`.
+            const onDesktop = keptOnDesktop(cfg, sourceRoot);
+            const targetDir = onDesktop ? log.path('attachments') : projectTargetDir(cfg, projectName);
             await removeLegacyFlatMirror(cfg).catch(() => undefined);
             /*
              * A selection that cannot be copied stops the task before anything is sent: the chat would
              * otherwise work without the files it was promised. The copies already there are kept.
              */
             const result = await mirrorProject({
-                rootDir: session.mirror.rootDir,
+                rootDir: sourceRoot,
                 // `rules-engine` in a plan usually means the repository's folder, wherever the root is.
                 alsoUnder: [repoDirOf(session)],
                 includeDirs: session.mirror.includeDirs.length ? session.mirror.includeDirs : ['.'],
@@ -744,7 +763,7 @@ export async function runTask(transport, session, task, deps) {
                 sink.event('mirror-refused', { error: result.message }, result.message, 'error');
                 return await finish('failed', `${result.message} Nothing was sent to the chat. Fix the files to attach and queue the task again.`);
             }
-            sink.event('mirror', { targetDir, ...result }, `project mirror: ${describeMirror(result)}`);
+            sink.event('mirror', { targetDir, onDesktop, ...result }, `project mirror${onDesktop ? ' (attachments, in the run folder: the Desktop copy is kept by the Desktop mirror)' : ''}: ${describeMirror(result)}`);
             if (session.mirror.includeEnvFiles) {
                 const envCount = Object.keys(result.mapping).filter((p) => /(^|\/)\.env(\.|$)/i.test(p)).length;
                 if (envCount > 0) {

package/dist/src/plan/brief.js

@@ -432,6 +432,16 @@ is clean: the runner commits after the checks, and its own commit is what leaves
 - \`"previous-session"\` — the session carries on from the end of the branch of the session that
   ran before it **in the same repository**, so the sessions form a chain. The first session of
   such a chain starts from \`baseBranch\`. Sessions in other repositories do not count.
+- \`"existing-branch"\` with \`existingBranch\` — no new branch at all: every task of the session
+  works on that existing local branch, exactly as named (\`"existingBranch": "recovery/apz-migration"\`),
+  one after another, building on what is already on it. For new work that continues a branch the
+  user already has. The branch must exist when the plan is imported; \`branchMode\`, \`branchName\`
+  and the prefix do not apply.
+
+Before a session's first branch the runner fetches and fast-forwards the branch it starts from
+(\`baseBranch\`, or \`existingBranch\`), so the work begins from the server's code; it never resets or
+merges. \`"updateFromRemote": false\` turns that off — only when the user asks to work offline or from
+local commits on purpose.
 
 Put the same \`startFrom\` on every session that works in one repository unless the user wants it
 mixed. Leaving it out keeps the old behaviour — whatever branch the repository is on — which is
@@ -479,6 +489,15 @@ const VCS_DETAIL_BG = `
 - \`"previous-session"\` — сесията продължава от края на клона на сесията, пусната преди нея **в
   същото хранилище**, така че сесиите образуват верига. Първата сесия от веригата тръгва от
   \`baseBranch\`. Сесии в други хранилища не се броят.
+- \`"existing-branch"\` с \`existingBranch\` — без нов клон: всяка задача от сесията работи на този
+  съществуващ локален клон, точно с това име (\`"existingBranch": "recovery/apz-migration"\`), една след
+  друга, върху това, което вече е там. За нова работа, която продължава клон, който потребителят вече
+  има. Клонът трябва да съществува при импорта; \`branchMode\`, \`branchName\` и представката не се прилагат.
+
+Преди първия клон на сесията runner-ът прави fetch и fast-forward на клона, от който тя тръгва
+(\`baseBranch\` или \`existingBranch\`), така че работата започва от кода на сървъра; никога не прави
+reset или merge. \`"updateFromRemote": false\` го изключва — само ако потребителят поиска да работи
+офлайн или нарочно от локални commit-и.
 
 Сложи един и същ \`startFrom\` на всички сесии в едно хранилище, освен ако потребителят не иска
 различни. Ако го пропуснеш, остава старото поведение — от който клон е хранилището в момента —

package/dist/src/plan/importPlan.js

@@ -169,6 +169,9 @@ persona = '') {
         const vcs = { ...DEFAULT_VCS, ...(planned.vcs ?? {}) };
         vcs.branchPrefix = vcs.branchPrefix.trim() || DEFAULT_VCS.branchPrefix;
         vcs.repoDir = vcs.repoDir.trim();
+        // A branch to carry on, given alone, is that choice: see `VersionControl.startFrom`.
+        if (vcs.existingBranch?.trim())
+            vcs.startFrom = 'existing-branch';
         const group = planned.conversationGroup.trim() || sharedGroup;
         await store.updateSession(created.id, (s) => {
             s.onFailure = planned.onFailure;

package/dist/src/plan/schema.js

@@ -44,16 +44,40 @@ const VcsInput = z
      * Absent keeps the old behaviour, wherever the repository is. See `VersionControl.startFrom`.
      */
     startFrom: z
-        .enum(['branch', 'previous-session', 'head'], {
-        error: 'startFrom must be "branch" (every session starts from the local branch in baseBranch, "main" unless said otherwise) or "previous-session" (each session carries on from the branch of the session before it in the same repository).',
+        .enum(['branch', 'previous-session', 'head', 'existing-branch'], {
+        error: 'startFrom must be "branch" (every session starts from the local branch in baseBranch, "main" unless said otherwise), "previous-session" (each session carries on from the branch of the session before it in the same repository) or "existing-branch" (the session works on the existing branch named in existingBranch).',
     })
         .optional(),
     /** The local branch `startFrom: "branch"` starts from, and `previous-session`'s fallback. */
     baseBranch: z.string().trim().optional(),
+    /**
+     * The existing local branch the whole session works on, exactly as named: no new branch, no
+     * prefix. Given alone it means `startFrom: "existing-branch"`. See `VersionControl.startFrom`.
+     */
+    existingBranch: z.string().trim().optional(),
+    /**
+     * Fetch and fast-forward the branch the session starts from before its first branch is cut.
+     * Absent means true. See `VersionControl.updateFromRemote`.
+     */
+    updateFromRemote: z.boolean().optional(),
 }, {
     error: 'Every session needs a "vcs" object saying whether the runner does version control for it and, when it does, which git repository to work in. Ask the user both questions and write the answers here.',
 })
     .superRefine((vcs, ctx) => {
+    if (vcs.startFrom === 'existing-branch' && !vcs.existingBranch) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['existingBranch'],
+            message: 'startFrom is "existing-branch", so "existingBranch" must name the local branch to carry on, exactly as it is in git (for example "recovery/apz-migration").',
+        });
+    }
+    if (vcs.existingBranch && vcs.startFrom && vcs.startFrom !== 'existing-branch') {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['existingBranch'],
+            message: `"existingBranch" carries on a branch that exists, and startFrom "${vcs.startFrom}" cuts a new one. Keep one: startFrom "existing-branch" with existingBranch, or leave existingBranch out.`,
+        });
+    }
     if (vcs.enabled && !vcs.repoDir.trim()) {
         ctx.addIssue({
             code: 'custom',

package/dist/src/plan/script.js

@@ -669,6 +669,10 @@ export const SCRIPT = [
                         en: "From the previous session's branch — the sessions form a chain (previous-session)",
                         bg: 'От клона на предната сесия — сесиите образуват верига (previous-session)',
                     },
+                    {
+                        en: 'On an existing branch — no new branch, the work continues on it; name it (existing-branch + existingBranch)',
+                        bg: 'На съществуващ клон — без нов клон, работата продължава на него; посочи го (existing-branch + existingBranch)',
+                    },
                 ],
             },
             {
@@ -944,82 +948,82 @@ export function scriptSection(stages, projects, lang) {
         return `### ${m.when[lang]}\n\n${quoted.join('\n')}`;
     });
     const head = lang === 'bg'
-        ? `## Въпросите, дословно
-
-Всяко съобщение, в което питаш оператора нещо, е тук — дословно, в реда, в който идват. **Копирай го
-точно:** същите въпроси, в същия ред, със същите номера, същите опции и същите редове *Пример:*. Не
-добавяй въпрос, не махай, не сливай, не разделяй, не преформулирай и не пренареждай — операторът учи
-разговора, а това става само ако той е един и същ всеки път. Заглавието над цитата е за теб: казва
-кога се праща съобщението; операторът вижда само цитираното, без знака \`>\`.
-
-- **Първият ред на всеки цитат е редът за фазата.** Копираш го както е; не го сменяш и не добавяш
-  друг.
-- **Номерата са само цифри.** Въпросите са 1, 2, 3; опциите под въпрос 2 са 2.1, 2.2, 2.3. Никога
-  букви. Съобщение с един-единствен избор номерира опциите си 1, 2, 3.
-- **Попълваш само това в {скоби}** — път, име, брой, присъда — и нищо друго не пишеш наново.
-  **Съобщение с непопълнени {скоби} не се изпраща никога**: ако не знаеш с какво да ги попълниш,
-  значи съобщението не е за сега.
-- **Препоръка:** на въпрос с опции, освен на тези за това какво операторът има или знае, може да
-  добавиш след една опция *(препоръчвам — причината в няколко думи)*. Само ако имаш причина.
-- **Вече казано:** ако отговорът на въпрос вече е даден — в документите на оператора по-горе или
-  по-рано в този разговор — въпросът остава на мястото си, а под него, след празен ред и със същия
-  отстъп като редовете *Пример:*, пишеш \`${ALREADY_SAID.bg} …\` с отговора — отделен ред, не в края на
-  въпроса; на избор отбелязваш опцията с *(вече казано)*. Отговорът е целият, не етикет: за
-  заданието — заглавието, целта и контекстът от „Тази работа“, не само заглавието; за критериите —
-  всеки от тях. Операторът потвърждава това, което вижда, и не може да потвърди нещо, което не е
-  показано. Последният ред
-  на цитата тогава е точно един от тези два: когато всеки въпрос е вече казан — *${ON_RECORD_ALL.bg}*
-  — а когато само някои — *${ON_RECORD_MIXED.bg}*
-- **Около цитата:** преди него — само поздравът, и то само в първото съобщение; след него — нищо: без
-  „Очаквам отговорите ти“ и без „Когато си готов…“. Последният ред на цитата вече казва какво следва.
-  Съобщенията, които не питат нищо, също започват с реда за фазата си и свършват на последната си
-  стъпка. Редът за фаза 2 е \`${PHASE_LINES.p2.bg}\`.
-- **Единственото място за твои въпроси** е мъгляв или липсващ отговор във фаза 1: тогава, преди
-  настройките, пращаш едно съобщение с уточнения — редът за фазата, само номерирани въпроси, 1, 2, 3,
-  с опции 1.1, 1.2, когато отговорите могат да се изброят, и същия последен ред като тук.
-
-Съобщенията, които не питат нищо — JSON-ът, стъпките в приложението, диагнозата, таблицата с
+        ? `## Въпросите, дословно
+
+Всяко съобщение, в което питаш оператора нещо, е тук — дословно, в реда, в който идват. **Копирай го
+точно:** същите въпроси, в същия ред, със същите номера, същите опции и същите редове *Пример:*. Не
+добавяй въпрос, не махай, не сливай, не разделяй, не преформулирай и не пренареждай — операторът учи
+разговора, а това става само ако той е един и същ всеки път. Заглавието над цитата е за теб: казва
+кога се праща съобщението; операторът вижда само цитираното, без знака \`>\`.
+
+- **Първият ред на всеки цитат е редът за фазата.** Копираш го както е; не го сменяш и не добавяш
+  друг.
+- **Номерата са само цифри.** Въпросите са 1, 2, 3; опциите под въпрос 2 са 2.1, 2.2, 2.3. Никога
+  букви. Съобщение с един-единствен избор номерира опциите си 1, 2, 3.
+- **Попълваш само това в {скоби}** — път, име, брой, присъда — и нищо друго не пишеш наново.
+  **Съобщение с непопълнени {скоби} не се изпраща никога**: ако не знаеш с какво да ги попълниш,
+  значи съобщението не е за сега.
+- **Препоръка:** на въпрос с опции, освен на тези за това какво операторът има или знае, може да
+  добавиш след една опция *(препоръчвам — причината в няколко думи)*. Само ако имаш причина.
+- **Вече казано:** ако отговорът на въпрос вече е даден — в документите на оператора по-горе или
+  по-рано в този разговор — въпросът остава на мястото си, а под него, след празен ред и със същия
+  отстъп като редовете *Пример:*, пишеш \`${ALREADY_SAID.bg} …\` с отговора — отделен ред, не в края на
+  въпроса; на избор отбелязваш опцията с *(вече казано)*. Отговорът е целият, не етикет: за
+  заданието — заглавието, целта и контекстът от „Тази работа“, не само заглавието; за критериите —
+  всеки от тях. Операторът потвърждава това, което вижда, и не може да потвърди нещо, което не е
+  показано. Последният ред
+  на цитата тогава е точно един от тези два: когато всеки въпрос е вече казан — *${ON_RECORD_ALL.bg}*
+  — а когато само някои — *${ON_RECORD_MIXED.bg}*
+- **Около цитата:** преди него — само поздравът, и то само в първото съобщение; след него — нищо: без
+  „Очаквам отговорите ти“ и без „Когато си готов…“. Последният ред на цитата вече казва какво следва.
+  Съобщенията, които не питат нищо, също започват с реда за фазата си и свършват на последната си
+  стъпка. Редът за фаза 2 е \`${PHASE_LINES.p2.bg}\`.
+- **Единственото място за твои въпроси** е мъгляв или липсващ отговор във фаза 1: тогава, преди
+  настройките, пращаш едно съобщение с уточнения — редът за фазата, само номерирани въпроси, 1, 2, 3,
+  с опции 1.1, 1.2, когато отговорите могат да се изброят, и същия последен ред като тук.
+
+Съобщенията, които не питат нищо — JSON-ът, стъпките в приложението, диагнозата, таблицата с
 доказателствата — следват описанието във фазата си.`
-        : `## The questions, word for word
-
-Every message in which you ask the operator something is here — word for word, in the order they
-come. **Copy it exactly:** the same questions, in the same order, with the same numbers, the same
-options and the same *Example:* lines. Do not add a question, drop one, merge, split, reword or
-reorder — the operator learns the conversation, and that only works if it is the same every time. The
-heading above each quotation is for you: it says when the message is sent; the operator sees only
-what is quoted, without the \`>\`.
-
-- **The first line of every quotation is the phase line.** Copy it as it is; do not change it and do
-  not add another.
-- **Numbers are digits only.** Questions are 1, 2, 3; the options under question 2 are 2.1, 2.2, 2.3.
-  Never letters. A message with one single choice numbers its options 1, 2, 3.
-- **You fill in only what is in {braces}** — a path, a name, a count, a verdict — and write nothing
-  else afresh. **A message with unfilled {braces} is never sent**: if you do not know what goes in
-  them, the message is not for now.
-- **Recommending:** on a question with options, except those about what the operator has or knows,
-  you may add after one option *(recommended — the reason in a few words)*. Only when you have one.
-- **Already said:** if a question has already been answered — in the operator's documents above or
-  earlier in this conversation — the question stays where it is and, under it, after a blank line
-  and indented like the *Example:* lines, you write \`${ALREADY_SAID.en} …\` with the answer — a line
-  of its own, not the end of the question; on a choice you mark the option *(already said)*. The
-  answer is the whole of it, not a label: for the assignment, the title, the goal and the context from
-  "This work", not the title alone; for the criteria, every one of them. The operator confirms what
-  they see, and cannot confirm what is not shown.
-  The last line of the quotation is then exactly one of these two: when every question is already
-  answered — *${ON_RECORD_ALL.en}* — and when only some are — *${ON_RECORD_MIXED.en}*
-- **Around the quotation:** before it, only the greeting, and only in the first message; after it,
-  nothing: no "I look forward to your answers", no "When you are ready…". The quotation's last line
-  already says what happens next. Messages that ask nothing also open with their phase line and end
-  on their last step. The phase 2 line is \`${PHASE_LINES.p2.en}\`.
-- **The one place for questions of your own** is a vague or missing answer in phase 1: then, before
-  the settings, you send one message of follow-ups — the phase line, numbered questions only, 1, 2,
-  3, with options 1.1, 1.2 where the answers can be listed, and the same last line as here.
-
-Messages that ask nothing — the JSON, the steps in the app, the diagnosis, the table of evidence —
+        : `## The questions, word for word
+
+Every message in which you ask the operator something is here — word for word, in the order they
+come. **Copy it exactly:** the same questions, in the same order, with the same numbers, the same
+options and the same *Example:* lines. Do not add a question, drop one, merge, split, reword or
+reorder — the operator learns the conversation, and that only works if it is the same every time. The
+heading above each quotation is for you: it says when the message is sent; the operator sees only
+what is quoted, without the \`>\`.
+
+- **The first line of every quotation is the phase line.** Copy it as it is; do not change it and do
+  not add another.
+- **Numbers are digits only.** Questions are 1, 2, 3; the options under question 2 are 2.1, 2.2, 2.3.
+  Never letters. A message with one single choice numbers its options 1, 2, 3.
+- **You fill in only what is in {braces}** — a path, a name, a count, a verdict — and write nothing
+  else afresh. **A message with unfilled {braces} is never sent**: if you do not know what goes in
+  them, the message is not for now.
+- **Recommending:** on a question with options, except those about what the operator has or knows,
+  you may add after one option *(recommended — the reason in a few words)*. Only when you have one.
+- **Already said:** if a question has already been answered — in the operator's documents above or
+  earlier in this conversation — the question stays where it is and, under it, after a blank line
+  and indented like the *Example:* lines, you write \`${ALREADY_SAID.en} …\` with the answer — a line
+  of its own, not the end of the question; on a choice you mark the option *(already said)*. The
+  answer is the whole of it, not a label: for the assignment, the title, the goal and the context from
+  "This work", not the title alone; for the criteria, every one of them. The operator confirms what
+  they see, and cannot confirm what is not shown.
+  The last line of the quotation is then exactly one of these two: when every question is already
+  answered — *${ON_RECORD_ALL.en}* — and when only some are — *${ON_RECORD_MIXED.en}*
+- **Around the quotation:** before it, only the greeting, and only in the first message; after it,
+  nothing: no "I look forward to your answers", no "When you are ready…". The quotation's last line
+  already says what happens next. Messages that ask nothing also open with their phase line and end
+  on their last step. The phase 2 line is \`${PHASE_LINES.p2.en}\`.
+- **The one place for questions of your own** is a vague or missing answer in phase 1: then, before
+  the settings, you send one message of follow-ups — the phase line, numbered questions only, 1, 2,
+  3, with options 1.1, 1.2 where the answers can be listed, and the same last line as here.
+
+Messages that ask nothing — the JSON, the steps in the app, the diagnosis, the table of evidence —
 follow the description in their phase.`;
-    return `
-${head}
-
-${blocks.join('\n\n')}
+    return `
+${head}
+
+${blocks.join('\n\n')}
 `;
 }

package/dist/src/plan/systemGuide.js

@@ -1128,6 +1128,30 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'The old behaviour, and what a session without a choice does: whatever branch is checked out at its first run, often the one the previous session left.',
                         doesBg: 'Старото поведение и това, което прави сесия без избор: какъвто клон е избран при първото ѝ пускане, често оставеният от предната сесия.',
                     },
+                    {
+                        key: 'vcs.startExisting',
+                        kind: 'radio',
+                        en: 'Carry on an existing branch',
+                        bg: 'Продължи съществуващ клон',
+                        doesEn: 'No new branch: every task works on the branch named under it, exactly as in git. A missing branch or uncommitted changes refuse the task; nothing runs.',
+                        doesBg: 'Без нов клон: всяка задача работи на клона, посочен под него, точно както е в git. Липсващ клон или незакомитнати промени отказват задачата; нищо не се изпълнява.',
+                    },
+                    {
+                        key: 'vcs.existingBranch',
+                        kind: 'field',
+                        en: 'The branch to carry on',
+                        bg: 'Клонът, който да продължи',
+                        doesEn: 'The exact name of the branch "Carry on an existing branch" works on; the repository\'s local branches are offered as you type.',
+                        doesBg: 'Точното име на клона, на който работи „Продължи съществуващ клон“; докато пишеш, се предлагат локалните клонове.',
+                    },
+                    {
+                        key: 'vcs.updateFromRemote',
+                        kind: 'checkbox',
+                        en: 'Bring the starting branch up to date from the remote first',
+                        bg: 'Първо обнови началния клон от отдалеченото хранилище',
+                        doesEn: 'On by default. Before the session\'s first branch: git fetch, then a fast-forward of the starting branch only; a branch with its own commits is left and said.',
+                        doesBg: 'Включено по подразбиране. Преди първия клон на сесията: git fetch и само fast-forward на началния клон; клон със свои commit-и се оставя и се казва.',
+                    },
                     {
                         key: 'vcs.baseBranch',
                         kind: 'field',
@@ -2190,6 +2214,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'The same button once the story is open: folds it away again.',
                         doesBg: 'Същият бутон, когато историята е отворена: сгъва я обратно.',
                     },
+                    {
+                        key: 'reg.rerunHere',
+                        kind: 'button',
+                        en: 'Run only this one again',
+                        bg: 'Пусни само тази отново',
+                        doesEn: 'On a row that failed or blocked on its work: says what happens to the chat, branch and record, then starts a new attempt of that task alone; the rest of the queue stays.',
+                        doesBg: 'На ред, провален или блокиран по работата: казва какво става с чата, клона и записа, после пуска нов опит само за тази задача; останалите в опашката остават.',
+                    },
                     {
                         key: 'reg.continueHere',
                         kind: 'button',
@@ -2439,17 +2471,17 @@ export const SYSTEM_GUIDE = [
                     {
                         key: 'reg.pickAll',
                         kind: 'button',
-                        en: 'All of them',
-                        bg: 'Всички',
+                        en: 'Tick all',
+                        bg: 'Маркирай всички',
                         doesEn: 'In that panel: ticks every task.',
                         doesBg: 'В панела: отметва всички задачи.',
                     },
                     {
                         key: 'reg.pickNone',
                         kind: 'button',
-                        en: 'None',
-                        bg: 'Нито една',
-                        doesEn: 'In that panel: unticks every task (the start buttons then do nothing until one is ticked).',
+                        en: 'Untick all',
+                        bg: 'Размаркирай всички',
+                        doesEn: 'In that panel: unticks every task, beside the count of ticked ones (the start buttons then do nothing until one is ticked).',
                         doesBg: 'В панела: маха всички отметки (бутоните за пускане тогава не действат, докато не се отметне поне една).',
                     },
                     {

package/dist/src/session/exports.js

@@ -144,6 +144,9 @@ export function buildPlanExport(scope) {
                     // Only when chosen: absent is the old behaviour, and writing it out would suggest a choice.
                     ...(s.vcs?.startFrom ? { startFrom: s.vcs.startFrom } : {}),
                     ...(s.vcs?.baseBranch ? { baseBranch: s.vcs.baseBranch } : {}),
+                    ...(s.vcs?.existingBranch ? { existingBranch: s.vcs.existingBranch } : {}),
+                    // Only when switched off: absent is on.
+                    ...(s.vcs?.updateFromRemote === false ? { updateFromRemote: false } : {}),
                 },
                 review: { enabled: s.review?.enabled !== false, model: s.review?.model ?? '' },
                 mirror: {