copilot-operator 0.1.41 → 0.1.43

package/dist/src/protocol/parser.js

@@ -142,11 +142,33 @@ export function normaliseProse(value) {
             });
         }
     }
+    // A plan's prose, in plan mode: read as text whatever shape it came in, as the fields above are.
+    if (out.plan && typeof out.plan === 'object' && !Array.isArray(out.plan)) {
+        const plan = { ...out.plan };
+        for (const key of ['existing', 'approach', 'verification', 'risks']) {
+            if (key in plan && plan[key] !== undefined && typeof plan[key] !== 'string') {
+                plan[key] = proseOf(plan[key]);
+                coerced.push(`plan.${key}`);
+            }
+        }
+        for (const key of ['steps', 'files']) {
+            if (typeof plan[key] === 'string') {
+                // One item per line, its numbering or bullet taken off: "1. add the writer\n2. add the route".
+                plan[key] = plan[key]
+                    .split(/\r?\n/)
+                    .map((l) => l.replace(/^\s*(?:\d+[.)]|[-*•])\s+/, '').trim())
+                    .filter(Boolean);
+                coerced.push(`plan.${key}`);
+            }
+        }
+        out.plan = plan;
+    }
     return { value: out, coerced };
 }
 /** What each field must look like, said in the message that asks for a reformatted reply. */
 const FIELD_SHAPES = [
-    [/^status$/, '"status" is one of "continue", "done", "blocked"'],
+    [/^status$/, '"status" is one of "continue", "done", "blocked" — and "plan", in plan mode only'],
+    [/^plan(\.|$)/, '"plan" is {"existing": "…", "approach": "…", "steps": ["…"], "files": ["…"], "verification": "…", "risks": "…"} with plain strings'],
     [/^steps(\.|$)/, '"steps" is a list of {"id": 1, "type": "command", "cmd": "the command"} ("shell", "expect", "timeoutSec" optional)'],
     [/^tried(\.|$)/, '"tried" is a list of plain strings, one sentence per approach'],
     [/^deviations(\.|$)/, '"deviations" is a list of {"instruction": "…", "did": "…", "why": "…"} with plain strings'],
@@ -210,10 +232,12 @@ export function parseReply(markdown, opts) {
             // model that writes "Край" under an explanation of why it cannot finish has ended the
             // task, not completed it, and reading that as `done` would file a failure as a success.
             const blocked = reply.status === 'blocked';
+            // A plan waits for its approval: the stop word in it does not end the task.
+            const plan = reply.status === 'plan';
             return {
                 ok: true,
                 reply: { ...reply, steps },
-                done: reply.status === 'done' || (markerHit && hasSummary && !blocked),
+                done: reply.status === 'done' || (markerHit && hasSummary && !blocked && !plan),
                 blocked,
                 json: text.trim(),
                 ...(prose.coerced.length > 0 ? { coerced: prose.coerced } : {}),

package/dist/src/protocol/replySchema.js

@@ -90,6 +90,21 @@ export const DisputeSchema = z.object({
     /** What shows it: the command run and what came back, quoted. */
     evidence: z.string().trim().min(1),
 });
+/** A list item that arrived as an object or a number: read as its text, since nothing in a plan is run. */
+const asText = (v) => typeof v === 'string' ? v : v && typeof v === 'object' ? Object.values(v).map((x) => (typeof x === 'string' ? x : JSON.stringify(x))).join(' — ') : String(v ?? '');
+/**
+ * The plan of a task in plan mode (see `PlanMode` in session/model.ts): what is already there, how the
+ * task will be done, its stages, the files it touches, how the result will be shown to work, and the
+ * risks. Prose, never run; a list item in another shape is read as its text.
+ */
+export const PlanSchema = z.object({
+    existing: z.string().trim().min(1, 'plan.existing must say what is already in the project that the task touches: the files, functions and behaviour you found.'),
+    approach: z.string().trim().min(1, 'plan.approach must say how you mean to do the task.'),
+    steps: z.array(z.preprocess(asText, z.string().trim().min(1))).min(1, 'plan.steps must list the stages, in order.'),
+    files: z.array(z.preprocess(asText, z.string().trim().min(1))).default([]),
+    verification: z.string().trim().min(1, 'plan.verification must say how you will show the result works.'),
+    risks: z.string().optional(),
+});
 export const ReplySchema = z
     .object({
     /**
@@ -105,8 +120,13 @@ export const ReplySchema = z
      * costing a message, a reply and a report, and ending in a timeout that says nothing about
      * why. A task that stops with "I tried these three things and this is in the way" is a
      * result. A task that runs out of iterations is not.
+     *
+     * `plan` — in plan mode only: here is the plan, made from what I read; no steps with it, and no change
+     * made yet. See `PlanSchema`.
      */
-    status: z.enum(['continue', 'done', 'blocked']),
+    status: z.enum(['continue', 'done', 'blocked', 'plan']),
+    /** Required when `status` is `plan`. */
+    plan: PlanSchema.optional(),
     steps: z.array(StepSchema).default([]),
     notes: z.string().optional(),
     /**
@@ -138,8 +158,12 @@ export const ReplySchema = z
         'Send at least one step, or set status to "done" or "blocked".',
 })
     .refine((r) => r.status === 'continue' || r.steps.length === 0, {
-    message: 'status "done" and status "blocked" both end the task, so they cannot carry steps. ' +
-        'Send the steps with status "continue" first, then end.',
+    message: 'status "done", "blocked" and "plan" cannot carry steps: "done" and "blocked" end the task, and "plan" waits for the plan to be approved. ' +
+        'Send the steps with status "continue".',
+})
+    .refine((r) => r.status !== 'plan' || !!r.plan, {
+    message: 'status "plan" requires a "plan" object: { "existing": what is already there, "approach": how, "steps": [the stages], ' +
+        '"files": [the files you will create or change], "verification": how you will show it works, "risks": optional }.',
 })
     .refine((r) => r.status !== 'done' || (r.summary ?? '').trim().length >= MIN_SUMMARY_CHARS, {
     message: 'status "done" requires a real summary: several sentences explaining what was done, ' +
@@ -190,7 +214,7 @@ export function describeDeviations(deviations) {
  * because forgetting to repeat is more common than meaning to retract.
  */
 export function resolveDeviations(existing, status, incoming) {
-    if (status !== 'continue' && incoming.length > 0)
+    if (status !== 'continue' && status !== 'plan' && incoming.length > 0)
         return mergeDeviations([], incoming);
     return mergeDeviations(existing, incoming);
 }

package/dist/src/session/compose.js

@@ -1,4 +1,18 @@
 import { describeInterruption } from './interruption.js';
+/** The operator's notes about a task, as the chat is given them: with the opening, or with a report while it runs. */
+export function operatorNotesSection(notes, whileWorking) {
+    if (notes.length === 0)
+        return '';
+    return [
+        whileWorking
+            ? `## ${notes.length > 1 ? 'Notes' : 'A note'} from the operator, while you work`
+            : `## ${notes.length > 1 ? 'Notes' : 'A note'} from the operator about this task`,
+        '',
+        'Take this into account from now on; where it and the task disagree, this wins.',
+        '',
+        ...notes.map((n) => (notes.length > 1 ? `- ${n.text.trim().replace(/\n/g, '\n  ')}` : n.text.trim())),
+    ].join('\n');
+}
 const LEVEL2_HEADER = '## Project instructions (level 2)';
 const TASK_HEADER = '## Task';
 /**
@@ -11,7 +25,7 @@ const TASK_HEADER = '## Task';
  * and a note that is empty simply leaves nothing behind.
  */
 function runnerBlock(input) {
-    const notes = [input.workDirNote, input.readOnlyNote, input.scopeNote, input.approachesNote, input.vcsNote, input.shellNote].map((n) => (n ?? '').trim()).filter((n) => n.length > 0);
+    const notes = [input.workDirNote, input.readOnlyNote, input.scopeNote, input.approachesNote, input.vcsNote, input.shellNote, input.planNote, input.operatorNotes].map((n) => (n ?? '').trim()).filter((n) => n.length > 0);
     return notes.length > 0 ? `${notes.join('\n\n')}\n\n` : '';
 }
 /**
@@ -52,6 +66,8 @@ function level2Block(level2) {
  * the steps it had just asked for actually ran.
  */
 function whyItStopped(c) {
+    if (c.how === 'failed')
+        return describeEnding(c.fromAttempt, c.ended, c.stoppedBecause);
     if (c.how === 'interrupted') {
         const where = c.interruption ? `\n\n${describeInterruption(c.interruption)}\n\n` : ' ';
         return ('The runner stopped unexpectedly while this task was in progress — the program was closed, the machine went off or it ' +
@@ -71,6 +87,33 @@ function whyItStopped(c) {
     const which = c.limit ? ` of ${LIMIT_WORDS[c.limit.setting](c.limit.value)}` : '';
     return `It stopped because the runner's limit${which} was reached${why} — not because anything failed. The files are as you left them.`;
 }
+/**
+ * How an attempt ended without the work being done, in the words the chat is sent: its status and the
+ * runner's reason, the checks that did not pass, what the independent review found, and the attempt's
+ * own summary. The chat that carries it on needs the why as much as the what (2026-10-13).
+ */
+export function describeEnding(fromAttempt, ended, reason) {
+    const status = ended?.status ?? 'failed';
+    const why = (ended?.reason ?? reason ?? '').trim();
+    const lines = [`The previous attempt (attempt ${fromAttempt}) did not succeed: it ended ${status}${why ? ` — ${why}` : '.'}`];
+    if (ended?.failedChecks?.length) {
+        lines.push('', 'The checks that did not pass:');
+        for (const c of ended.failedChecks)
+            lines.push(`- ${c.name}: ${c.detail}`);
+    }
+    if (ended?.findings?.length) {
+        lines.push('', 'What the independent review found:');
+        for (const f of ended.findings)
+            lines.push(`- ${f.what}${f.where ? ` (${f.where})` : ''}: ${f.evidence}`);
+    }
+    if (ended?.summary)
+        lines.push('', `That attempt's own summary: ${ended.summary}`);
+    return lines.join('\n');
+}
+/** The operator's new prompt, as its own section of the message. */
+function instructionSection(text) {
+    return `## New instruction from the operator\n\nAdded to the task above, not in place of it; where the two disagree, this wins.\n\n${text.trim()}`;
+}
 /** Each limit from the settings, as the chat is told about it. See `TaskLimit`. */
 const LIMIT_WORDS = {
     maxRunMinutes: (n) => `${n} minutes per task`,
@@ -87,23 +130,49 @@ export function composeOpening(input) {
      * again — sending it would read as a new task and start the work over. Only when the
      * conversation was lost does the task go out in full, with a line saying it is a continuation.
      */
+    const instruction = input.instruction?.text.trim() ? input.instruction : undefined;
     if (input.continuing && input.contractAlreadySent) {
-        const message = `Continue task ${input.taskNumber}: ${input.taskTitle.trim() || 'untitled'}, in this same conversation. ` +
+        const title = input.taskTitle.trim() || 'untitled';
+        /*
+         * After a failure, with the operator's new prompt: told how it ended and why, that its files are
+         * there, and what to do now — not "carry on from your plan", which is the plan that failed.
+         */
+        if (input.continuing.how === 'failed' && instruction) {
+            const message = `Continue task ${input.taskNumber}: ${title}, in this same conversation, with a new instruction from the operator.\n\n` +
+                `${whyItStopped(input.continuing)}\n\n` +
+                `The files are as that attempt left them, and what it changed is in your working tree. Do not start over: look at ` +
+                `what is there first, keep what is right, and do what the instruction below says. The assignment is the one you ` +
+                `were given above, with the instruction added to it. Verify the result as for any task. Step numbering restarts at 1.\n\n` +
+                `${instructionSection(instruction.text)}\n\n` +
+                `${runnerBlock(input)}`.trimEnd();
+            return { messages: [message], firstMessage: message };
+        }
+        const message = `Continue task ${input.taskNumber}: ${title}, in this same conversation. ` +
             `${whyItStopped(input.continuing)} ` +
             `Do not start over and do not repeat work that is done: start from ` +
             `your plan, say in \`notes\` which stages are done and which one you are on, and carry on. ` +
-            `The assignment is the one you were given above; it has not changed. Step numbering restarts at 1.\n\n` +
+            (instruction
+                ? `The assignment is the one you were given above, with the operator's instruction below added to it. Step numbering restarts at 1.\n\n${instructionSection(instruction.text)}\n\n`
+                : `The assignment is the one you were given above; it has not changed. Step numbering restarts at 1.\n\n`) +
             `${runnerBlock(input)}`.trimEnd();
         return { messages: [message], firstMessage: message };
     }
     const continuationLine = input.continuing
-        ? `\n\nThis continues an earlier attempt at this task. ${whyItStopped(input.continuing)} ` +
-            `Look at what is already done before changing anything, and carry on from there.`
+        ? `\n\nThis continues an earlier attempt at this task. ${whyItStopped(input.continuing)}` +
+            (input.continuing.how === 'failed'
+                ? `\n\nWhat that attempt changed is in your working tree. Look at it before changing anything, keep what is right, and do what the instruction below says.`
+                : ` Look at what is already done before changing anything, and carry on from there.`) +
+            (instruction ? `\n\n${instructionSection(instruction.text)}` : '')
         : input.buildsOn
             ? `\n\nThis task was done once already (attempt ${input.buildsOn.fromAttempt}), and that work is in your ` +
                 `working tree. The text above is a new instruction for it: look at what is there first, build on it, and ` +
-                `change or undo it only where the new instruction asks. Verify the result as for any task.`
-            : '';
+                `change or undo it only where the new instruction asks. Verify the result as for any task.` +
+                (instruction ? `\n\n${describeEnding(instruction.fromAttempt, instruction.ended)}\n\n${instructionSection(instruction.text)}` : '')
+            : instruction
+                ? // The attempt it follows never reached a conversation: what is known of its ending, then the prompt.
+                    `\n\nAn earlier attempt at this task never reached this conversation. ${describeEnding(instruction.fromAttempt, instruction.ended)}` +
+                        `\n\n${instructionSection(instruction.text)}`
+                : '';
     if (!input.contractAlreadySent) {
         const taskMessage = `${runnerBlock(input)}${level2Block(input.level2)}\n\n${taskBlock}${continuationLine}`;
         return {

package/dist/src/session/exports.js

@@ -137,6 +137,7 @@ export function buildPlanExport(scope) {
                 onFailure: s.onFailure ?? 'stop',
                 level2: split.level2,
                 conversationGroup: shared ? '' : (s.conversationGroup ?? ''),
+                ...(s.planMode ? { planMode: s.planMode } : {}),
                 vcs: {
                     enabled: s.vcs?.enabled ?? false,
                     repoDir: s.vcs?.repoDir ?? '',

package/dist/src/session/model.js

@@ -12,6 +12,44 @@ export function tidyVcsPlan(plan) {
         return undefined;
     return { ...(branch ? { branch } : {}), ...(commitMessage ? { commitMessage } : {}) };
 }
+export const clipText = (s, n) => {
+    const t = (s ?? '').trim();
+    if (!t)
+        return undefined;
+    return t.length > n ? `${t.slice(0, n)}…` : t;
+};
+/**
+ * How a task's latest attempt ended, for the next one to be told: its status and reason, its own
+ * summary, the checks that did not pass and what the independent review found — clipped, since it
+ * goes into a chat message.
+ */
+export function endingOf(t) {
+    const failedChecks = (t.checkResults ?? []).filter((c) => !c.passed).slice(0, 10).map((c) => ({ name: c.name, detail: clipText(c.detail, 400) ?? '' }));
+    const findings = t.review?.verdict === 'fail'
+        ? (t.review.findings ?? []).slice(0, 10).map((f) => ({ what: clipText(f.what, 400) ?? '', ...(f.where ? { where: clipText(f.where, 200) } : {}), evidence: clipText(f.evidence, 400) ?? '' }))
+        : [];
+    const reason = clipText(t.reason, 2000);
+    const summary = clipText(t.summary, 2000);
+    return {
+        status: t.status,
+        ...(reason ? { reason } : {}),
+        ...(summary && summary !== reason ? { summary } : {}),
+        ...(t.stopCode ? { stopCode: t.stopCode } : {}),
+        ...(failedChecks.length > 0 ? { failedChecks } : {}),
+        ...(findings.length > 0 ? { findings } : {}),
+    };
+}
+/**
+ * Whether a task can be carried on with a new prompt after it failed: it ended failed or blocked on its
+ * work. Not one that contradicted itself — it never started its work, and its way on is the fix of the
+ * contradiction. A task that stopped at a limit or was stopped is continued anyway (`isContinuable`),
+ * with a new prompt or without.
+ */
+export function canFollowUp(t) {
+    return (t.status === 'failed' || t.status === 'blocked') && t.stopCode !== 'contract-conflict';
+}
+/** The longest new prompt taken: it goes into one chat message beside the task. */
+export const MAX_INSTRUCTION_CHARS = 20_000;
 /**
  * Whether "Continue" may carry a task on where it stopped, in its chat and on its branch.
  *

package/dist/src/session/store.js

@@ -11,7 +11,7 @@ import { mkdir, readFile, writeFile, readdir, rename, rm } from 'node:fs/promise
 import { existsSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { join, resolve } from 'node:path';
-import { isContinuable, newId, tidyVcsPlan } from './model.js';
+import { endingOf, isContinuable, MAX_INSTRUCTION_CHARS, newId, tidyVcsPlan } from './model.js';
 /** A task the runner is inside of. It cannot be edited, deleted, or left behind at startup. */
 const ACTIVE_STATUSES = ['running', 'waiting-approval'];
 /**
@@ -107,6 +107,10 @@ export const TASK_FIELD_ON_RERUN = {
     leftovers: 'archived',
     environment: 'archived',
     handoff: 'archived',
+    plan: 'archived',
+    accepted: 'archived',
+    // Every note stays with the task; the ones not sent yet go out with the next attempt's opening.
+    notes: 'kept',
     interruption: 'cleared',
     finalReply: 'cleared',
     firstMessage: 'cleared',
@@ -525,12 +529,35 @@ export class SessionStore {
      */
     async continueTask(sessionId, taskId, 
     /** Where an attempt the operator stopped had got to, read from its run folder by the caller. */
-    stoppedAt) {
+    stoppedAt, 
+    /**
+     * The operator's new prompt (2026-10-13): what carries a task that failed or blocked on from where
+     * it got to, and may come with any other Continue. See `TaskContinuation.instruction`.
+     */
+    instruction) {
         const current = (await this.getSession(sessionId))?.tasks.find((x) => x.id === taskId);
         if (!current)
             throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
+        const text = instruction?.trim() || undefined;
+        if (text && text.length > MAX_INSTRUCTION_CHARS)
+            throw new Error(`The new prompt is ${text.length} characters; it can be at most ${MAX_INSTRUCTION_CHARS}.`);
         if (!isContinuable(current)) {
-            throw new Error('Only a task that stopped before it finished, or at a limit from the settings, can be continued; run this one again instead.');
+            if (current.status === 'failed' || current.status === 'blocked') {
+                if (current.stopCode === 'contract-conflict') {
+                    throw new Error('This task never started its work: it contradicts itself. Fix the contradiction ("Fix the contradiction"), then run it.');
+                }
+                if (!text)
+                    throw new Error('A task that failed is carried on with a new prompt: say what to do now. To run it again as it is, use "Run again".');
+                // The task as it ended, before the attempt is archived: what the chat is told about it.
+                return await this.rerunTask(sessionId, taskId, {}, {
+                    fromAttempt: current.attempt ?? 1,
+                    stoppedBecause: current.reason,
+                    how: 'failed',
+                    instruction: text,
+                    ended: endingOf(current),
+                });
+            }
+            throw new Error('Only a task that stopped before it finished, at a limit from the settings, or that failed can be continued; run this one again instead.');
         }
         const how = current.status === 'limit-reached' || current.limit ? 'limit' : current.interruption ? 'interrupted' : 'stopped';
         return await this.rerunTask(sessionId, taskId, {}, {
@@ -539,7 +566,63 @@ export class SessionStore {
             how,
             ...(current.limit ? { limit: current.limit } : {}),
             ...(current.interruption ? { interruption: current.interruption } : how === 'stopped' && stoppedAt ? { interruption: stoppedAt } : {}),
+            ...(text ? { instruction: text } : {}),
+        });
+    }
+    /**
+     * A note from the operator to the chat about this task (2026-10-14): it goes out with the next message the
+     * task sends — the opening of its next attempt, or the next report while it runs. See `Task.notes`.
+     */
+    async addTaskNote(sessionId, taskId, text) {
+        const note = text.trim();
+        if (!note)
+            throw new Error('The note is empty.');
+        if (note.length > MAX_INSTRUCTION_CHARS)
+            throw new Error(`The note is ${note.length} characters; it can be at most ${MAX_INSTRUCTION_CHARS}.`);
+        let result;
+        await this.updateSession(sessionId, (s) => {
+            const t = s.tasks.find((x) => x.id === taskId);
+            if (!t)
+                throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
+            t.notes = [...(t.notes ?? []), { id: newId('n-'), text: note, at: new Date().toISOString() }];
+            result = t;
         });
+        return result;
+    }
+    /** Marks notes as sent with this attempt's message; returns the ones it marked. */
+    async takeUnsentNotes(sessionId, taskId) {
+        let taken = [];
+        await this.updateSession(sessionId, (s) => {
+            const t = s.tasks.find((x) => x.id === taskId);
+            if (!t?.notes?.some((n) => !n.sentAt))
+                return;
+            const at = new Date().toISOString();
+            taken = t.notes.filter((n) => !n.sentAt);
+            t.notes = t.notes.map((n) => (n.sentAt ? n : { ...n, sentAt: at, attempt: t.attempt ?? 1 }));
+        });
+        return taken;
+    }
+    /**
+     * The operator accepts a task as done though it did not end so (2026-10-14): what it was is kept beside it,
+     * and the run's chain goes on past it as past any done task.
+     */
+    async acceptTask(sessionId, taskId, note) {
+        const text = note?.trim() || undefined;
+        if (text && text.length > MAX_INSTRUCTION_CHARS)
+            throw new Error(`The note is ${text.length} characters; it can be at most ${MAX_INSTRUCTION_CHARS}.`);
+        let result;
+        await this.updateSession(sessionId, (s) => {
+            const t = s.tasks.find((x) => x.id === taskId);
+            if (!t)
+                throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
+            if (!['failed', 'blocked', 'limit-reached', 'aborted'].includes(t.status)) {
+                throw new Error(t.status === 'done' ? 'This task is done already.' : 'Only a task that ended without being done can be accepted as done.');
+            }
+            t.accepted = { at: new Date().toISOString(), was: t.status, ...(t.reason ? { reason: t.reason } : {}), ...(text ? { note: text } : {}) };
+            t.status = 'done';
+            result = t;
+        });
+        return result;
     }
     /**
      * What a new attempt does with each field of a task — see `TASK_FIELD_ON_RERUN`.
@@ -595,6 +678,8 @@ export class SessionStore {
                     inputsRestored: t.inputsRestored,
                     artifactsKept: t.artifactsKept,
                     vcs: t.vcs,
+                    plan: t.plan,
+                    accepted: t.accepted,
                 },
             ];
             // An edit is applied only after the old attempt has been put beyond its reach.
@@ -627,6 +712,8 @@ export class SessionStore {
             // marks itself again after this, in the runner.
             t.stats = undefined;
             t.handoff = undefined;
+            t.plan = undefined;
+            t.accepted = undefined;
             t.scopeReverted = undefined;
             t.treeChanged = undefined;
             t.inputsRestored = undefined;

package/dist/src/vcs/startChoice.js

@@ -1,6 +1,6 @@
-import { git, isAncestor, isValidBranchName, lastFetchedAt } from './git.js';
+import { freeBranchName, git, isAncestor, isValidBranchName, lastFetchedAt } from './git.js';
 import { fetchAsOperator, fetchCommandFor } from './remoteAuth.js';
-import { describeStart, remoteTip, repoDirOf } from './taskVcs.js';
+import { describeStart, remoteTip, repoDirOf, sessionBranchName } from './taskVcs.js';
 const lines = (s) => s.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
 const norm = (dir) => dir.trim().replace(/[\\/]+$/, '').replace(/\//g, '\\').toLowerCase();
 /** A task of the session has run: a start recorded since then is the one its work stands on. */
@@ -109,10 +109,17 @@ export async function startOptions(sessions) {
             repoDir: repo.repoDir,
             previousOffered: s.vcs?.startFrom === 'previous-session' || earlierHere,
         };
-        if (startIsFixed(s) && s.vcsStart)
-            entry.fixed = describeStart(s.vcsStart);
-        else if (startIsFixed(s))
-            entry.fixed = `it started from ${s.vcsBaseCommit?.slice(0, 8)}`;
+        if (startIsFixed(s)) {
+            entry.fixed = s.vcsStart ? describeStart(s.vcsStart) : `it started from ${s.vcsBaseCommit?.slice(0, 8)}`;
+            if (!repo.problem) {
+                entry.started = await startedOn(s, repo);
+                // What "another branch" offers first: the session's own setting, as for a session that has not run.
+                entry.choice = defaultChoice(s, repo);
+                const carries = carriedOn(s);
+                if (carries.length > 0)
+                    entry.rechooseBlocked = carries.join(', ');
+            }
+        }
         else {
             if (s.vcsStart)
                 entry.prepared = describeStart(s.vcsStart);
@@ -123,6 +130,32 @@ export async function startOptions(sessions) {
     }
     return { repos: [...repos.values()], sessions: out };
 }
+/** The queued tasks that carry an earlier attempt on, on that attempt's branch: by title, quoted. */
+function carriedOn(s) {
+    return s.tasks.filter((t) => t.status === 'queued' && (t.continuing || t.buildsOn)).map((t) => `"${t.title}"`);
+}
+/** Where a session that has run stands: see `StartOptionSession.started`. */
+async function startedOn(s, repo) {
+    const dir = repo.repoDir;
+    const mode = s.vcs?.startFrom === 'existing-branch' ? 'existing-branch' : s.vcs?.branchMode === 'per-session' ? 'per-session' : 'per-task';
+    const branch = mode === 'existing-branch' ? s.vcs?.existingBranch?.trim() : mode === 'per-session' ? sessionBranchName(s) : s.vcsStart?.branch;
+    const recorded = s.vcsStart?.commit ?? s.vcsBaseCommit;
+    let tipNow = null;
+    let remote;
+    if (branch) {
+        if (mode === 'per-task' && s.vcsStart?.remote && branch.startsWith(`${s.vcsStart.remote}/`)) {
+            tipNow = await remoteTip(dir, s.vcsStart.remote, branch.slice(s.vcsStart.remote.length + 1));
+        }
+        else {
+            tipNow = repo.local.find((b) => b.name === branch)?.commit ?? null;
+            const r = s.vcs?.baseRemote?.trim() || defaultRemote(repo);
+            const theirs = r ? repo.remotes.find((x) => x.name === r)?.branches.find((b) => b.name === branch) : undefined;
+            if (r && theirs)
+                remote = { name: `${r}/${branch}`, commit: theirs.commit };
+        }
+    }
+    return { mode, ...(branch ? { branch } : {}), ...(recorded ? { recorded } : {}), tipNow, ...(remote ? { remote } : {}) };
+}
 /**
  * Checks a choice against the repository and works out what it sets. Nothing is written to the session
  * here; for `remote` with `onBranch` the local branch is made, or moved forward, since that is the
@@ -130,8 +163,47 @@ export async function startOptions(sessions) {
  * only says whether it could be done (every session of a run is checked so before any branch moves).
  */
 export async function applyStartChoice(session, choice, opts = {}) {
-    // Nothing to choose without version control, or once the start is fixed: see `startIsFixed`.
-    if (!session.vcs?.enabled || startIsFixed(session))
+    // Nothing to choose without version control; a start that is fixed is kept unless chosen again.
+    if (!session.vcs?.enabled)
+        return { ok: true };
+    if (!startIsFixed(session))
+        return await chooseStart(session, choice, opts);
+    if (!choice.rechoose)
+        return { ok: true };
+    /*
+     * Chosen again after the session ran (operator's report, 2026-10-13: "the retry remains permanently bound
+     * to the session's original branch and commit"). Not while a queued task carries an earlier attempt on:
+     * that attempt's work is on its own branch, and the task goes on there.
+     */
+    const carries = carriedOn(session);
+    if (carries.length > 0) {
+        return {
+            ok: false,
+            problem: `${carries.join(', ')} ${carries.length === 1 ? 'carries' : 'carry'} an earlier attempt on, on its own branch, so where "${session.name}" starts stays as it is. ` +
+                'To start it from another branch, queue it with "Fix the prompt and queue it again" instead.',
+        };
+    }
+    const done = await chooseStart(session, choice, opts);
+    if (!done.ok || !done.applied)
+        return done;
+    const applied = done.applied;
+    // A branch carried on is the new one itself; the one branch of a per-session session goes on under a new name.
+    const perSession = session.vcs.branchMode === 'per-session' && (applied.vcs.startFrom ?? session.vcs.startFrom) !== 'existing-branch';
+    const freshBranch = perSession && !opts.dry ? await freeBranchName(repoDirOf(session), sessionBranchName(session)) : undefined;
+    return {
+        ok: true,
+        applied: {
+            ...applied,
+            clearStart: true,
+            restart: freshBranch ? { freshBranch } : {},
+            said: `${applied.said} — chosen again after the session had run: the tasks that run next start from it, a task run again included` +
+                (freshBranch ? `, on the new branch ${freshBranch} (${sessionBranchName(session)} keeps what was done on it)` : ''),
+        },
+    };
+}
+/** `applyStartChoice` for a session whose start is not fixed: see there. */
+async function chooseStart(session, choice, opts) {
+    if (!session.vcs?.enabled)
         return { ok: true };
     const dir = repoDirOf(session);
     const before = pointOf(session.vcs);