copilot-operator 0.1.5 → 0.1.7

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

@@ -133,7 +133,8 @@ let OperatorController = class OperatorController {
         return this.ops.continueTask(id, taskId).catch(fail);
     }
     rerunTask(id, taskId, body) {
-        return this.ops.rerunTask(id, taskId, body ?? {}).catch(fail);
+        const { buildOnFinished, ...patch } = body ?? {};
+        return this.ops.rerunTask(id, taskId, patch, { buildOnFinished: buildOnFinished === true }).catch(fail);
     }
     /** What going back to before this task would do. Changes nothing. */
     restorePreview(id, taskId) {
@@ -177,6 +178,19 @@ let OperatorController = class OperatorController {
             throw new NotFoundException('This task has not run yet, or that attempt is not its own.');
         return story;
     }
+    /**
+     * What a task changed: the files between the commit it started from and the one it produced.
+     * `run` picks an earlier attempt. See `taskChanges`.
+     */
+    taskChanges(id, taskId, run) {
+        return this.ops.taskChanges(id, taskId, run?.trim() || undefined).catch(fail);
+    }
+    /** One of those files, before and after. Only a file the task changed can be asked for. */
+    taskChangeFile(id, taskId, path, run) {
+        if (!path)
+            throw new BadRequestException('path is required');
+        return this.ops.taskChangeFile(id, taskId, path, run?.trim() || undefined).catch(fail);
+    }
     taskFiles(id, taskId, run) {
         return this.ops.taskFiles(id, taskId, run);
     }
@@ -320,13 +334,15 @@ let OperatorController = class OperatorController {
     startBatch(body) {
         if (!Array.isArray(body?.sessionIds))
             throw new BadRequestException('sessionIds must be a list of session ids');
+        if (body?.taskIds !== undefined && !Array.isArray(body.taskIds))
+            throw new BadRequestException('taskIds must be a list of task ids');
         return this.ops
             .startBatch(body.sessionIds, body?.mode === 'unattended' ? 'unattended' : 'confirm', body?.onFailure === 'continue' ? 'continue' : 'stop', 
         // Absent or empty means every session keeps the model it already has, which is not the
         // same as "no model": an empty string on a session means "leave the chat alone".
         body?.model, 
         // The same for the review: absent means each session keeps whatever it is set to.
-        body?.reviewModel, body?.name)
+        body?.reviewModel, body?.name, body?.taskIds)
             .catch(fail);
     }
     stopBatch() {
@@ -726,6 +742,25 @@ __decorate([
     __metadata("design:paramtypes", [String, String, String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "taskStory", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/changes'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskChanges", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/changes/file'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('path')),
+    __param(3, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskChangeFile", null);
 __decorate([
     Get('sessions/:id/tasks/:taskId/files'),
     __param(0, Param('id')),

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

@@ -20,7 +20,7 @@ import { installLayout } from '../config/layout.js';
 import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW } from '../session/store.js';
 import { EventBus } from '../session/events.js';
 import { newId, tidyVcsPlan } from '../session/model.js';
-import { runSession, openBrowser } from '../orchestrator/taskRunner.js';
+import { runSession, openBrowser, queuedToRun } from '../orchestrator/taskRunner.js';
 import { buildExport } from '../session/exportRecord.js';
 import { buildDebugExport } from '../session/debugExport.js';
 import { buildPlanExport, buildDomainExport, buildBotExport, buildBundleExport, exportFileName, exportMachine, taskAtAttempt, withTask, writeAttemptRecord } from '../session/exports.js';
@@ -36,8 +36,8 @@ function sameFolder(a, b) {
     return a.trim() !== '' && norm(a) === norm(b);
 }
 import { importPlan, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
-import { commitInterrupted, vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
-import { gitAvailable, repoUnusableReason } from '../vcs/git.js';
+import { commitInterrupted, repoDirOf, vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
+import { changedFilesBetween, fileAt, gitAvailable, 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';
@@ -328,16 +328,26 @@ let OperatorService = class OperatorService {
         });
         return task;
     }
-    async rerunTask(sessionId, taskId, patch = {}) {
+    async rerunTask(sessionId, taskId, patch = {}, 
+    /**
+     * A new prompt for a task that ended done builds on what it did: the next attempt works on
+     * that attempt's branch. Only for a done task — a failed attempt's work is what is being
+     * replaced, so a re-run of one starts again from where the task first started.
+     */
+    opts = {}) {
         await this.init();
-        const task = await this.store.rerunTask(sessionId, taskId, patch);
+        const before = (await this.store.getSession(sessionId))?.tasks.find((t) => t.id === taskId);
+        const buildsOn = opts.buildOnFinished && before?.status === 'done' ? { fromAttempt: before.attempt ?? 1 } : undefined;
+        const task = await this.store.rerunTask(sessionId, taskId, patch, undefined, buildsOn);
         this.bus.publish({
             sessionId,
             taskId,
             type: 'task-requeued',
             level: 'info',
-            message: `"${task.title}" is queued again (attempt ${task.attempt ?? 1})`,
-            data: { attempt: task.attempt },
+            message: buildsOn
+                ? `"${task.title}" is queued again with a new prompt that builds on attempt ${buildsOn.fromAttempt} (attempt ${task.attempt ?? 1})`
+                : `"${task.title}" is queued again (attempt ${task.attempt ?? 1})`,
+            data: { attempt: task.attempt, ...(buildsOn ? { buildsOn } : {}) },
         });
         return task;
     }
@@ -378,6 +388,78 @@ let OperatorService = class OperatorService {
         return await buildStory(cfg.resolved.runsDir, chosen, view, live);
     }
     /** Files a task produced, so the UI can list reports and downloaded scripts. */
+    /**
+     * What a task changed in the repository: the files, between the commit it started from and the
+     * commit it produced. `runId` picks an earlier attempt. Read from git each time rather than kept
+     * on the record, so what is shown is the repository's own account; the record only says which
+     * two commits to compare.
+     *
+     * There is something to show only when version control was on and the task committed: a task
+     * that changed nothing, or ran with version control off, left no commit to compare, and the
+     * answer says which.
+     */
+    async taskChanges(sessionId, taskId, runId) {
+        const found = await this.changesOf(sessionId, taskId, runId);
+        if ('problem' in found)
+            return { ok: false, problem: found.problem, files: [] };
+        const listed = await changedFilesBetween(found.dir, found.base, found.commit);
+        if (listed.problem)
+            return { ok: false, problem: `the repository no longer has these commits: ${listed.problem}`, files: [] };
+        return { ok: true, repoDir: found.dir, branch: found.branch, base: found.base, commit: found.commit, files: listed.files };
+    }
+    /**
+     * One changed file, before and after, as text. Only a file the task changed can be asked for:
+     * the path is checked against that list, so this cannot be used to read anything else in the
+     * repository's history. A binary file, or one over 2 MB on either side, is said to be so rather
+     * than returned.
+     */
+    async taskChangeFile(sessionId, taskId, path, runId) {
+        const found = await this.changesOf(sessionId, taskId, runId);
+        if ('problem' in found)
+            throw new Error(found.problem);
+        const listed = await changedFilesBetween(found.dir, found.base, found.commit);
+        const file = listed.files.find((f) => f.path === path);
+        if (!file)
+            throw new Error('That file is not one this task changed.');
+        const MAX = 2 * 1024 * 1024;
+        const before = file.status === 'A' ? { bytes: null, tooLarge: false } : await fileAt(found.dir, found.base, file.oldPath ?? file.path, MAX);
+        const after = file.status === 'D' ? { bytes: null, tooLarge: false } : await fileAt(found.dir, found.commit, file.path, MAX);
+        // Git's own test for binary: a NUL byte in the first 8000.
+        const binary = [before.bytes, after.bytes].some((b) => !!b && b.subarray(0, 8000).includes(0));
+        const text = (b) => (b === null || binary ? null : b.toString('utf8').replace(/^\uFEFF/, ''));
+        return {
+            path: file.path,
+            ...(file.oldPath ? { oldPath: file.oldPath } : {}),
+            status: file.status,
+            before: text(before.bytes),
+            after: text(after.bytes),
+            binary,
+            tooLarge: before.tooLarge || after.tooLarge,
+        };
+    }
+    /** The repository and the two commits a task's changes lie between, or why there are none. */
+    async changesOf(sessionId, taskId, runId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        const task = session?.tasks.find((t) => t.id === taskId);
+        if (!session || !task)
+            return { problem: 'No such task.' };
+        const chosen = runId ? resolveRunId(task, runId) : task.runId;
+        if (runId && !chosen)
+            return { problem: 'That attempt is not one of this task\'s.' };
+        const vcs = !chosen || chosen === task.runId ? task.vcs : (task.attempts ?? []).find((a) => a.runId === chosen)?.vcs;
+        if (!vcs?.baseCommit || !vcs.commit) {
+            return {
+                problem: vcs?.branch
+                    ? 'This attempt committed nothing, so there are no changes to show.'
+                    : 'Version control was not on for this attempt, so its changes were not recorded.',
+            };
+        }
+        const dir = repoDirOf(session);
+        if (!dir)
+            return { problem: 'The session has no repository folder set.' };
+        return { dir, base: vcs.baseCommit, commit: vcs.commit, branch: vcs.branch };
+    }
     async taskFiles(sessionId, taskId, runId) {
         const cfg = await this.settings.load();
         const s = await this.store.getSession(sessionId);
@@ -643,7 +725,9 @@ let OperatorService = class OperatorService {
     /** A browser that is already open. A batch passes its own; a single run opens one. */
     transport, 
     /** The press of a start button this belongs to, stamped onto every task it reaches. */
-    runGroup) {
+    runGroup, 
+    /** Only these queued tasks, when the operator chose some; the rest stay queued. */
+    onlyTasks) {
         await this.init();
         // Every project's Desktop copy brought up to date before the chat opens, when the operator
         // asked for that. Before the run rather than before each task: a task's own mirror already
@@ -655,7 +739,7 @@ let OperatorService = class OperatorService {
         const session = await this.store.getSession(sessionId);
         if (!session)
             return { started: false, reason: 'no such session', done: Promise.resolve(idle) };
-        const queuedIds = session.tasks.filter((t) => t.status === 'queued').map((t) => t.id);
+        const queuedIds = queuedToRun(session, onlyTasks).map((t) => t.id);
         if (queuedIds.length === 0)
             return { started: false, reason: 'no queued tasks', done: Promise.resolve(idle) };
         const cfg = await this.settings.load();
@@ -714,6 +798,7 @@ let OperatorService = class OperatorService {
             continueOnFailure: session.onFailure === 'continue',
             transport,
             runGroup,
+            onlyTasks,
         })
             .then(async (outcome) => ({ ...(await this.tally(sessionId, queuedIds)), paused: outcome.paused }))
             .catch(async (e) => {
@@ -816,8 +901,15 @@ let OperatorService = class OperatorService {
      */
     reviewModel, 
     /** What to call the run. Offered from the plan's name; empty means it goes by its id. */
-    name) {
+    name, 
+    /**
+     * The queued tasks to run, when not every queued task of those sessions: what the operator
+     * ticked in the register. A session none of whose chosen tasks is queued is skipped; the
+     * tasks nobody chose stay queued exactly as they were. Absent means every queued task.
+     */
+    taskIds) {
         await this.init();
+        const onlyTasks = taskIds && taskIds.length > 0 ? new Set(taskIds.map((t) => t.trim()).filter(Boolean)) : undefined;
         if (this.batch?.running)
             return { started: false, reason: 'a batch is already running' };
         const wanted = [...new Set(sessionIds.map((s) => s.trim()).filter(Boolean))];
@@ -837,9 +929,9 @@ let OperatorService = class OperatorService {
                 sessions.push({ sessionId: id, name: id, state: 'skipped', ran: 0, failed: 0, reason: 'no such session' });
                 continue;
             }
-            const queued = s.tasks.filter((t) => t.status === 'queued').length;
+            const queued = queuedToRun(s, onlyTasks).length;
             sessions.push(queued === 0
-                ? { sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: 'nothing queued' }
+                ? { sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: onlyTasks ? 'none of its chosen tasks is queued' : 'nothing queued' }
                 : { sessionId: id, name: s.name, state: 'waiting', ran: 0, failed: 0 });
         }
         if (!sessions.some((s) => s.state === 'waiting')) {
@@ -899,6 +991,7 @@ let OperatorService = class OperatorService {
             id: newId('b-'),
             startedAt: new Date().toISOString(),
             name: chosenName,
+            ...(onlyTasks ? { onlyTasks: [...onlyTasks] } : {}),
             mode,
             onFailure,
             stopping: false,
@@ -1045,7 +1138,8 @@ let OperatorService = class OperatorService {
                     s.runGroup = {
                         ...runGroup,
                         order: at,
-                        taskIds: s.tasks.filter((t) => t.status === 'queued').map((t) => t.id),
+                        // What this run was asked to do: the chosen tasks, when some were chosen.
+                        taskIds: queuedToRun(s, batch.onlyTasks).map((t) => t.id),
                         mode: batch.mode,
                         onFailure: batch.onFailure,
                     };
@@ -1075,7 +1169,7 @@ let OperatorService = class OperatorService {
                     message: `starting as part of a batch of ${batch.sessions.length} session(s), in ${batch.mode} mode`,
                     data: { batchId: batch.id },
                 });
-                const begun = await this.beginRun(entry.sessionId, batch.mode, browser, runGroup);
+                const begun = await this.beginRun(entry.sessionId, batch.mode, browser, runGroup, batch.onlyTasks ? new Set(batch.onlyTasks) : undefined);
                 if (!begun.started) {
                     entry.state = 'skipped';
                     entry.reason = begun.reason;
@@ -1925,6 +2019,7 @@ let OperatorService = class OperatorService {
                     readOnly: t.readOnly || undefined,
                     autoRetries: t.autoRetries || undefined,
                     attempt: t.attempt,
+                    changedFiles: t.vcs?.commit && t.vcs.baseCommit ? (t.vcs.files?.length ?? 0) : undefined,
                     attempts: (t.attempts ?? []).map((a, n) => {
                         const from = a.startedAt ? Date.parse(a.startedAt) : undefined;
                         const to = a.finishedAt ? Date.parse(a.finishedAt) : undefined;
@@ -1939,6 +2034,7 @@ let OperatorService = class OperatorService {
                             reason: a.reason,
                             runId: a.runId,
                             branch: a.vcs?.branch,
+                            changedFiles: a.vcs?.commit && a.vcs.baseCommit ? (a.vcs.files?.length ?? 0) : undefined,
                         };
                     }),
                 });

package/dist/src/orchestrator/taskRunner.js

@@ -626,6 +626,7 @@ export async function runTask(transport, session, task, deps) {
             taskNumber,
             contractAlreadySent: session.contractSent,
             continuing: task.continuing,
+            buildsOn: task.buildsOn,
             workDirNote: workingDirNote(work),
             vcsNote: prepared.note,
             readOnlyNote: task.readOnly ? READ_ONLY_NOTE : undefined,
@@ -1462,6 +1463,15 @@ export async function runTask(transport, session, task, deps) {
         return await finish('failed', crash ? `${describeCrash(crash)}. Then: ${message}` : message);
     }
 }
+/**
+ * The queued tasks of a session a run takes: all of them, or only the ones the operator chose.
+ * One rule for the run itself and for every place that counts or records what a run will do, so
+ * the batch entrance, the run's record and the run cannot disagree about it.
+ */
+export function queuedToRun(session, onlyTasks) {
+    const only = onlyTasks ? new Set(onlyTasks) : undefined;
+    return session.tasks.filter((t) => t.status === 'queued' && (!only || only.has(t.id)));
+}
 /**
  * Runs every queued task of a session, in order, in one conversation. Stops at the first
  * task that does not end with `done` unless `continueOnFailure` is set, because a failed
@@ -1472,7 +1482,7 @@ export async function runSession(sessionId, deps) {
     let session = await store.getSession(sessionId);
     if (!session)
         throw new Error(`Session ${sessionId} does not exist.`);
-    const queued = session.tasks.filter((t) => t.status === 'queued');
+    const queued = queuedToRun(session, deps.onlyTasks);
     if (queued.length === 0) {
         bus.publish({ sessionId, type: 'session-idle', level: 'info', message: 'no queued tasks' });
         return { ran: 0, paused: false };

package/dist/src/plan/brief.js

@@ -633,6 +633,18 @@ your paraphrase means. Quote the label, and name the page by the route in the he
 button in the guide, say so and ask what they can see, rather than inventing one. A label written
 with {braces} is filled in with a number or a name at the time, so quote it with the braces and
 say what will be in them.
+
+**When asked what to do next, or where something is:** first be sure which page they are on and
+what they see — ask, in one line, if it is not clear. Then answer as numbered steps, each naming the
+page by its route, the section by its bold heading from the guide, and the control by its exact
+label. Say the condition a control needs when the guide gives one ("only in the **"Flow"** view",
+"only after **"Work on branches and commit what was changed"** is ticked"), because a control that is
+not showing is otherwise a control that "does not exist".
+
+**A run that looks stuck is usually waiting for them.** A step waiting for a decision appears at the
+top of every page under **"A step is waiting for your decision"**, one card per step, with **"Run"**,
+**"Run this and the rest without asking"**, **"Skip"** and **"Abort task"**; the browser tab then
+starts with "(n) waiting for you". Send them there first.
 `.trim();
 const GUIDE_RULE_BG = `
 ## Говори с думите от екрана
@@ -645,6 +657,18 @@ const GUIDE_RULE_BG = `
 **Никога не пращай оператора към контрол, който не е изброен там.** Ако това, което искаш да се
 направи, няма бутон в справочника, кажи го и попитай какво вижда, вместо да си измислиш. Надпис с
 {скоби} се попълва с число или име в момента — цитирай го със скобите и казвай какво ще има в тях.
+
+**Когато те питат какво следва или къде е нещо:** първо се увери на коя страница е операторът и
+какво вижда — попитай с един ред, ако не е ясно. После отговаряй с номерирани стъпки, като всяка
+назовава страницата с маршрута, раздела с удебеленото му заглавие от справочника и контрола с точния
+му надпис. Казвай условието, което контролът изисква, когато справочникът го дава („само в изгледа
+**„Поток“**“, „само след отметка на **„Работи по клонове и комитвай промененото“**“), защото
+контрол, който не се вижда, иначе е контрол, който „го няма“.
+
+**Пускане, което изглежда заседнало, обикновено чака оператора.** Стъпка, чакаща решение, се
+появява горе на всяка страница под **„Стъпка чака вашето решение“**, по една карта за стъпка, с
+**„Изпълни“**, **„Изпълни без да питаш повече“**, **„Пропусни“** и **„Прекрати задачата“**; разделът
+на браузъра тогава започва с „(n) чака вас“. Прати го там първо.
 `.trim();
 /**
  * The persona's two later roles, software level: what the operator brings back when a task
@@ -699,14 +723,23 @@ in those words, every time:
 - **A new prompt.** The task text was ambiguous, a path or a port was wrong, the level 2 forbade
   what the task needed, a check asked the git index about a file the runner had not committed yet,
   or the chat did the wrong thing and the checks caught it. Give the whole replacement text, then:
-  1. On \`/history\`, press **"Fix the prompt and queue it again"** on that row.
+  1. On \`/history\`, in the **"Flow"** view, press **"Fix the prompt and queue it again"** on that row.
   2. Replace the text with the one above and press **"Save and queue again"**.
-  3. Press **"Continue: run the {n} queued task(s) in {s} session(s)"**.
-  4. In **"Before it continues"**, press **"Continue without asking"** — the left-hand button —
-     to let it run, or **"Continue, asking before each command"** beside it to approve every one.
+  3. Under **"What is next"**, press **"Continue: run the {n} queued task(s) in {s} session(s)"**
+     (it reads **"Continue: run {f} failed and {n} queued task(s) in {s} session(s)"** when a chain
+     has a failed task).
+  4. In **"Before it continues"** every task is ticked. To run only the fixed one, press
+     **"only this one"** beside it.
+  5. Press **"Continue without asking"** — the left-hand button — to let it run, or
+     **"Continue, asking before each command"** beside it to approve every one.
 
   A check that is wrong rather than a prompt that is wrong is edited instead: **"Edit"** on the
-  task card, then **"What it checks"**, **"Must be"** and **"Command"** under **"Checks"**.
+  task card, then **"What it checks"**, **"Must be"** and **"Command"** under **"Checks"**, then
+  **"Save and queue it again"** — which, like every "queue" button, starts nothing by itself.
+  A task that ended **limit-reached** is carried on in its own chat instead: **"Continue in the
+  same chat"** on its card on the session page, then **"Run {n} task(s)"** at the top of that page.
+  When a failure shows up while the run is still going, **"Pause after this task"** holds the rest
+  while you work it out.
   Putting the repository back to before the task is **"Restore"**; putting it back and re-running
   that task and every task after it is **"Run again from here"**.
 - **A change to the bot.** No wording fixes it: the shell the task needs is not on the machine,
@@ -851,14 +884,23 @@ const PHASE3_BG = `
   забранявало това, което задачата иска, проверка е питала git индекса за файл, който runner-ът
   още не е комитнал, или чатът е направил грешното нещо и проверките са го хванали. Дай целия
   нов текст, после:
-  1. В \`/history\` натисни **„Поправи prompt-а и върни в опашката“** на този ред.
+  1. В \`/history\`, в изгледа **„Поток“**, натисни **„Поправи prompt-а и върни в опашката“** на този ред.
   2. Замени текста с горния и натисни **„Запази и върни в опашката“**.
-  3. Натисни **„Продължи: пусни {n} чакащи задачи в {s} сесии“**.
-  4. В **„Преди да продължи“** натисни **„Продължи без да пита“** — левият бутон — за да върви
-     само, или **„Продължи, с питане преди всяка команда“** до него, за да одобряваш всяка.
+  3. Под **„Какво следва“** натисни **„Продължи: пусни {n} чакащи задачи в {s} сесии“** (пише
+     **„Продължи: пусни {f} провалили се и {n} чакащи задачи в {s} сесии“**, когато във верига има
+     провалена задача).
+  4. В **„Преди да продължи“** всички задачи са отметнати. За да пуснеш само поправената, натисни
+     **„само тази“** до нея.
+  5. Натисни **„Продължи без да пита“** — левият бутон — за да върви само, или **„Продължи, с
+     питане преди всяка команда“** до него, за да одобряваш всяка.
 
   Когато е сгрешена проверката, а не prompt-ът, се редактира друго: **„Редактирай“** на картата
-  на задачата, после **„Какво проверява“**, **„Трябва“** и **„Команда“** под **„Проверки“**.
+  на задачата, после **„Какво проверява“**, **„Трябва“** и **„Команда“** под **„Проверки“**, после
+  **„Запази и върни в опашката“** — който, като всеки бутон за връщане в опашката, сам не пуска нищо.
+  Задача, завършила с **limit-reached**, продължава в собствения си чат: **„Продължи в същия чат“**
+  на картата ѝ на страницата на сесията, после **„Пусни {n} задача(и)“** горе на същата страница.
+  Когато провал се покаже, докато пускането още върви, **„Пауза след тази задача“** задържа
+  останалото, докато го разбереш.
   Връщането на хранилището отпреди задачата е **„Върни“**; връщането му плюс ново изпълнение на
   тази задача и всички след нея е **„Пусни отново оттук“**.
 - **Промяна по бота.** Никакви думи не го оправят: обвивката, която задачата иска, я няма на

package/dist/src/plan/script.js

@@ -658,6 +658,19 @@ export const SCRIPT = [
                     },
                 ],
             },
+            {
+                choose: { en: 'Where each session starts, if 1.1 (`startFrom`):', bg: 'Откъде тръгва всяка сесия, ако е 1.1 (`startFrom`):' },
+                options: [
+                    {
+                        en: 'From the local branch main — every session starts from the same clean code (branch; name another in baseBranch)',
+                        bg: 'От локалния клон main — всяка сесия тръгва от един и същ чист код (branch; друг клон в baseBranch)',
+                    },
+                    {
+                        en: "From the previous session's branch — the sessions form a chain (previous-session)",
+                        bg: 'От клона на предната сесия — сесиите образуват верига (previous-session)',
+                    },
+                ],
+            },
             {
                 choose: { en: 'If a task fails (`onFailure` of the session, required):', bg: 'Ако задача се провали (`onFailure` на сесията, задължително):' },
                 options: [