copilot-operator 0.1.41 → 0.1.43

package/dist/src/orchestrator/planMode.js

@@ -0,0 +1,102 @@
+/** Planning rounds after which the chat is reminded that a plan is what ends the phase. */
+export const PLAN_NUDGE_AFTER = 12;
+/** What the opening message says about the phase, for a task in plan mode. */
+export function planModeNote(mode, enforced, asks) {
+    return [
+        '## Plan first (plan mode)',
+        '',
+        'Before you change anything in this task, look at the project and make a plan. In this phase you only',
+        'read: list the folders, open the files the task touches, read the git log, search for what the task',
+        'names — find what is already implemented, what is missing and what a change would affect.',
+        enforced
+            ? 'Change nothing yet: the runner puts back any change made in this phase, and tells you.'
+            : 'Change nothing yet: nothing in this phase may change a file.',
+        'When you have seen enough, reply with status "plan" and no steps:',
+        '',
+        '```json',
+        '{"status": "plan", "notes": "…", "plan": {"existing": "what is already there that the task touches: files, functions, behaviour", "approach": "how you will do it", "steps": ["first stage", "second stage"], "files": ["the files you will create or change"], "verification": "how you will show the result works", "risks": "risks and open questions"}}',
+        '```',
+        '',
+        mode === 'approve' && asks
+            ? 'The operator reads the plan, and approves it or asks for another with what to change.'
+            : 'The runner approves the plan and tells you so.',
+        'Begin the work only once you are told the plan is approved. Then carry it out; when it has to change,',
+        'say so in `notes` and why. The independent review checks the work against the approved plan.',
+    ].join('\n');
+}
+/** The plan as the chat gave it, recorded. */
+export function planFrom(reply, version, revisions = []) {
+    return {
+        existing: reply.existing.trim(),
+        approach: reply.approach.trim(),
+        steps: reply.steps.map((x) => x.trim()).filter(Boolean),
+        files: reply.files.map((x) => x.trim()).filter(Boolean),
+        verification: reply.verification.trim(),
+        ...(reply.risks?.trim() ? { risks: reply.risks.trim() } : {}),
+        version,
+        at: new Date().toISOString(),
+        ...(revisions.length > 0 ? { revisions } : {}),
+    };
+}
+/** The plan in words: for the record, the reviewer and the approval card's plain-text form. */
+export function describePlan(plan) {
+    return [
+        `What is already there: ${plan.existing}`,
+        `Approach: ${plan.approach}`,
+        'Stages:',
+        ...plan.steps.map((x, i) => `${i + 1}. ${x}`),
+        ...(plan.files.length > 0 ? [`Files it will create or change: ${plan.files.join(', ')}`] : []),
+        `Verification: ${plan.verification}`,
+        ...(plan.risks ? [`Risks and open questions: ${plan.risks}`] : []),
+    ].join('\n');
+}
+/** Approved: the work begins. */
+export function planApprovedMessage(approval) {
+    const by = approval.by === 'operator'
+        ? 'The operator approved your plan.'
+        : `Your plan is approved by the runner${approval.why ? ` (${approval.why})` : ''}.`;
+    return [
+        by,
+        ...(approval.note?.trim() ? ['', 'With this from the operator, which wins where it and the plan disagree:', '', approval.note.trim()] : []),
+        '',
+        'Carry it out now: reply with status "continue" and the steps of its first stage. Keep to the plan; when it',
+        'has to change, say so in `notes` and why — a change the plan did not foresee is declared, not hidden.',
+        'Verify the result as the plan says before you report done. Step numbering restarts at 1.',
+    ].join('\n');
+}
+/** The operator asked for another plan. */
+export function planReviseMessage(comment, version) {
+    return [
+        `The operator read version ${version} of your plan and asks for another. What to change:`,
+        '',
+        comment.trim(),
+        '',
+        'You are still in the planning phase: change nothing. Look at what you need to, then reply with status',
+        '"plan" and the whole revised plan — not only what changed.',
+    ].join('\n');
+}
+/** A plan sent when none is asked for: the phase is over, or the session is not in plan mode. */
+export const PLAN_NOT_NOW = 'No plan is asked for now: the planning phase is over and the plan stands. Carry on with the work — reply with status ' +
+    '"continue" and steps, or end the task. When the plan has to change, say so in `notes` and why.';
+/** "done" in the planning phase: nothing has been done yet. */
+export const PLAN_FIRST = 'Not yet: this task is in the planning phase, and nothing has been changed. Reply with status "plan" and the plan; ' +
+    'the work begins once it is approved.';
+/** Said after many planning rounds. */
+export function planNudge(rounds) {
+    return `You have read the project for ${rounds} rounds in the planning phase. Send the plan now, with status "plan"; what you have not looked at yet can go under "risks".`;
+}
+/** The plan section of the reviewer's brief. */
+export function planForReviewer(plan) {
+    return [
+        '## The plan the work was to follow',
+        '',
+        `The implementer made this plan before it changed anything, and it was approved${plan.approved?.by === 'operator' ? ' by the operator' : ''}.`,
+        'Check that the work follows it: a stage left out, a file changed that the plan does not name, or another',
+        'approach — none of them declared in the implementer\'s notes or deviations with a reason — is a finding',
+        'with "about": "work". A departure the implementer declared and justified is not a fault in itself; judge',
+        'whether the reason holds. The work is still judged against the task as written first.',
+        ...(plan.approved?.note ? ['', `The operator added: ${plan.approved.note}`] : []),
+        '',
+        describePlan(plan),
+    ].join('\n');
+}

package/dist/src/orchestrator/review.js

@@ -31,6 +31,7 @@ import { writeReport } from '../exec/reportFile.js';
 import { mergeRedactions } from '../exec/redaction.js';
 import { trackedRepoOf } from '../vcs/taskVcs.js';
 import { buildCoveringMessage, assertSendable } from '../protocol/reporter.js';
+import { planForReviewer } from './planMode.js';
 import { inScope } from '../vcs/scope.js';
 /** The sentence both sides get when a review left something listening. */
 function leftoverNote(leftovers) {
@@ -52,7 +53,9 @@ export function deliverableFor(task, summary, tracked, changedFiles) {
         return { summary: text, why: 'no-files-changed' };
     return undefined;
 }
-export function reviewBrief(session, task, changedFiles, cwd, deviations = [], previous, disputes = [], derivedFailing = [], earlier = [], deliverable) {
+export function reviewBrief(session, task, changedFiles, cwd, deviations = [], previous, disputes = [], derivedFailing = [], earlier = [], deliverable, 
+/** The approved plan, in plan mode: see `planForReviewer`. */
+plan) {
     // The same repository the runner branched and read the changed files from, however it is named.
     const repo = trackedRepoOf(session);
     // Each file marked against the task's scope, and the scope said: the reviewer was shown side effects as
@@ -75,6 +78,7 @@ export function reviewBrief(session, task, changedFiles, cwd, deviations = [], p
         '## The project instructions that applied',
         '',
         task.level2.trim() || '(none)',
+        ...(plan ? ['', planForReviewer(plan)] : []),
         ...(earlier.length > 0
             ? [
                 '',
@@ -257,14 +261,14 @@ export async function runReview(transport, session, task, deps) {
         // The machine's shells, when they are not what the contract's example assumes — the same note
         // the implementer's conversation opens with, for a conversation working to the same example.
         const machineNote = shellNote(undefined, defaultShell);
-        let before = await transport.sendAndConfirm(machineNote ? `${contract}
-
+        let before = await transport.sendAndConfirm(machineNote ? `${contract}
+
 ${machineNote}` : contract);
         await transport.waitForReply(before);
         await pacer.throttleSend();
         // The brief is saved as sent. Until it was, whether a later round had been told what the
         // earlier one found could not be checked from the run folder at all.
-        const brief = reviewBrief(session, task, deps.changedFiles, deps.cwd, deps.deviations, deps.previous, deps.disputes, deps.derivedFailing, deps.earlier, deps.deliverable);
+        const brief = reviewBrief(session, task, deps.changedFiles, deps.cwd, deps.deviations, deps.previous, deps.disputes, deps.derivedFailing, deps.earlier, deps.deliverable, deps.plan);
         await saveReply('00-brief', brief);
         await deps.record(`REVIEW ${round} BRIEF`, brief);
         before = await transport.sendAndConfirm(brief);

package/dist/src/orchestrator/taskRunner.js

@@ -39,13 +39,15 @@ import { confinementRefusal, sessionRoots } from '../exec/confinement.js';
 import { writeReport } from '../exec/reportFile.js';
 import { Pacer } from '../util/pacing.js';
 import { RunLog } from '../log/runLog.js';
-import { composeOpening, readOnlyNote } from '../session/compose.js';
+import { composeOpening, operatorNotesSection, readOnlyNote } from '../session/compose.js';
 import { MIN_TRIED_APPROACHES } from '../protocol/replySchema.js';
 import { enforceScope, scopeMessage, scopeNote } from '../vcs/scope.js';
+import { PLAN_FIRST, PLAN_NOT_NOW, PLAN_NUDGE_AFTER, describePlan, planApprovedMessage, planFrom, planModeNote, planNudge, planReviseMessage } from './planMode.js';
 import { composeHandoff } from '../session/handoff.js';
 import { ProgressWatch } from './progress.js';
 import { contractConflicts, readsTreeClean } from './contract.js';
 import { treeFingerprint } from '../vcs/git.js';
+import { isContinuable } from '../session/model.js';
 import { prepareForTask, commitTaskResult, commitShortfall, repoDirOf, trackedRepoOf, whereLeft } from '../vcs/taskVcs.js';
 import { protectInputs, inputsMessage, inputsAtCommit, untrackedInputs, blobOfFile } from '../vcs/inputs.js';
 import { artifactPatterns, artifactState, keepArtifacts } from '../vcs/artifacts.js';
@@ -650,6 +652,14 @@ async function withOperatorHand(transport, wanted, first, hooks, sessionId, bus,
     return { result, goOnAsItIs: false };
 }
 /** Runs one task to completion inside an already-open transport. */
+/** The approved plan a task works to: its own attempt's, else, for a continuation, the latest one before it. */
+function approvedPlanOf(task) {
+    if (task.plan?.approved)
+        return task.plan;
+    if (!task.continuing)
+        return undefined;
+    return [...(task.attempts ?? [])].reverse().find((a) => a.plan?.approved)?.plan;
+}
 export async function runTask(transport, session, task, deps) {
     const { cfg, store, bus, authorizer, signal } = deps;
     // Every attempt gets its own folder. The first keeps the original name, so nothing that
@@ -1256,6 +1266,23 @@ export async function runTask(transport, session, task, deps) {
         const scopeEnforced = (scope.length > 0 || !!task.readOnly) && onOwnBranch;
         if (scopeEnforced)
             enforcement = { scope, readOnly: !!task.readOnly };
+        /*
+         * Plan mode (2026-10-13): the session's own, else Settings. A continuation carries on under the plan
+         * its attempt already has — it is in the conversation — so only a task that starts anew plans; a new
+         * prompt on finished work is a new instruction, and plans. The planning phase is read-only, enforced
+         * the way a read-only task is wherever the task has a branch of its own.
+         */
+        const planMode = session.planMode ?? cfg.execution.planMode ?? 'off';
+        let planning = planMode !== 'off' && !task.continuing;
+        const planEnforced = planning && onOwnBranch;
+        let planVersion = 0;
+        let planningRounds = 0;
+        const planRevisions = [];
+        /*
+         * The approved plan the work follows, for the reviewer: one approved in this attempt, or the earlier
+         * attempt's for a task carried on. Kept here, because `task` is the record as it was when the attempt began.
+         */
+        let planInForce = approvedPlanOf(task);
         if (watchesTree)
             startState = await treeState(repoDirOf(session));
         // The operator's input files, read-only on a branch of the task's own; see `vcs/inputs.ts`.
@@ -1373,6 +1400,8 @@ export async function runTask(transport, session, task, deps) {
         // --- opening messages -------------------------------------------------------------
         const { content: level1 } = await store.getLevel1();
         const taskNumber = session.tasks.findIndex((t) => t.id === task.id) + 1;
+        // The operator's notes not sent yet, marked sent as they go into this opening.
+        const openingNotes = await store.takeUnsentNotes(session.id, task.id).catch(() => []);
         const opening = composeOpening({
             level1,
             level2: task.level2,
@@ -1384,6 +1413,8 @@ export async function runTask(transport, session, task, deps) {
             contractAlreadySent: session.contractSent && !!session.chat,
             continuing,
             buildsOn,
+            // The operator's new prompt goes out whether or not the attempt it follows reached a conversation.
+            ...(task.continuing?.instruction ? { instruction: { text: task.continuing.instruction, fromAttempt: task.continuing.fromAttempt, ended: task.continuing.ended } } : {}),
             workDirNote: workingDirNote(work),
             vcsNote: prepared.note,
             // What is said about a commit is true only where one happens (live run 2026-10-03: promised with commits off).
@@ -1409,7 +1440,15 @@ export async function runTask(transport, session, task, deps) {
                     `each listed in "tried". With fewer, the runner asks you for another approach instead of accepting it.`
                 : undefined,
             shellNote: shellNote(shells, defaultShell),
+            ...(planning && planMode !== 'off'
+                ? { planNote: planModeNote(planMode, planEnforced, planMode === 'approve' && !!deps.approvePlan && (deps.currentMode?.() ?? cfg.execution.mode) === 'confirm') }
+                : {}),
+            // The operator's notes about this task not sent yet: they go out with this opening (2026-10-14).
+            ...(openingNotes.length > 0 ? { operatorNotes: operatorNotesSection(openingNotes, false) } : {}),
         });
+        if (openingNotes.length > 0) {
+            sink.event('operator-note-sent', { notes: openingNotes.length, with: 'opening' }, `${openingNotes.length} note(s) from the operator go out with the opening`);
+        }
         await setTask((t) => {
             t.firstMessage = opening.firstMessage;
         });
@@ -1857,6 +1896,11 @@ export async function runTask(transport, session, task, deps) {
                     deliverable,
                     deviations,
                     disputes,
+                    /*
+                     * The approved plan, for the review to hold the work to (plan mode, 2026-10-13): this attempt's, or —
+                     * carried on in its chat — the one the attempt it continues worked to.
+                     */
+                    ...(planInForce ? { plan: planInForce } : {}),
                     /*
                      * Each earlier finding with its evidence, the correction the implementer reports, and what the
                      * finding's own check came to at the last gate: the next reviewer judges the finding on the evidence,
@@ -2202,7 +2246,9 @@ export async function runTask(transport, session, task, deps) {
             await setTask((t) => {
                 t.iterations = iterations;
             });
-            const { reply, done, blocked } = parsed;
+            const { reply, blocked } = parsed;
+            // Nothing is done while the plan is being made: the stop word in a planning round ends nothing.
+            const done = parsed.done && !planning;
             sink.event('reply-parsed', { iteration: iterations, status: reply.status, steps: reply.steps.length, notes: reply.notes }, `iteration ${iterations}: ${reply.steps.length} step(s)${reply.notes ? ` — ${reply.notes}` : ''}`);
             /*
              * A deviation is recorded the moment it is declared, not when the task ends.
@@ -2262,6 +2308,81 @@ export async function runTask(transport, session, task, deps) {
              * what the reply said, at greater length and one message later. The reason carries the
              * approaches that were tried, and that is what the register shows.
              */
+            /*
+             * Plan mode: the reply that ends the planning phase — put to the operator or approved by the runner —
+             * and the two that do not belong in it. Answered here, in a message of its own, as a repair of the
+             * format is: no step runs and nothing is committed in between.
+             */
+            if (reply.status === 'plan' || (planning && reply.status === 'done')) {
+                let message;
+                let tag;
+                if (reply.status === 'done') {
+                    message = PLAN_FIRST;
+                    tag = 'plan-first';
+                    sink.event('plan-first', { iteration: iterations }, '"done" in the planning phase: nothing has been changed yet; the chat was asked for the plan', 'warn');
+                }
+                else if (!planning || !reply.plan) {
+                    message = PLAN_NOT_NOW;
+                    tag = 'plan-not-asked';
+                    sink.event('plan-not-asked', { iteration: iterations }, 'a plan arrived when none is asked for; the chat was told to carry on', 'warn');
+                }
+                else {
+                    planVersion += 1;
+                    tag = `plan-${planVersion}`;
+                    const plan = planFrom(reply.plan, planVersion, [...planRevisions]);
+                    await setTask((t) => {
+                        t.plan = plan;
+                    });
+                    await record(`PLAN ${planVersion}`, describePlan(plan));
+                    sink.event('plan-received', { version: planVersion, steps: plan.steps.length, files: plan.files }, `plan ${planVersion} received: ${plan.steps.length} stage(s)${plan.files.length > 0 ? `, ${plan.files.length} file(s)` : ''}`);
+                    // Asked of the operator only in a run that asks before each command: one that does not, approves it itself.
+                    const asks = planMode === 'approve' && !!deps.approvePlan && (deps.currentMode?.() ?? cfg.execution.mode) === 'confirm';
+                    let answer = { decision: 'approve' };
+                    if (asks) {
+                        sink.event('plan-waiting', { version: planVersion }, `plan ${planVersion} is waiting for the operator`, 'warn');
+                        answer = await deps.approvePlan({ sessionId: session.id, taskId: task.id, title: task.title, plan });
+                    }
+                    if (signal?.aborted || answer.decision === 'stop') {
+                        return await finish('aborted', answer.decision === 'stop' ? 'stopped by the operator at its plan' : 'stopped by the operator', undefined, lastMarkdown);
+                    }
+                    if (answer.decision === 'revise') {
+                        const comment = (answer.note ?? '').trim() || 'Make the plan more concrete: name the files and the stages.';
+                        planRevisions.push({ version: planVersion, comment, at: new Date().toISOString() });
+                        await setTask((t) => {
+                            if (t.plan)
+                                t.plan.revisions = [...planRevisions];
+                        });
+                        sink.event('plan-revise', { version: planVersion, comment }, `the operator asked for another plan: ${comment}`);
+                        message = planReviseMessage(comment, planVersion);
+                    }
+                    else {
+                        // Who approved it, and why the operator was not asked when they were not.
+                        const why = asks ? undefined : planMode === 'auto' ? 'plan mode approves plans automatically' : 'the run does not ask before each command';
+                        const approved = {
+                            by: asks ? 'operator' : 'auto',
+                            at: new Date().toISOString(),
+                            ...(answer.note?.trim() ? { note: answer.note.trim() } : {}),
+                            ...(why ? { why } : {}),
+                        };
+                        await setTask((t) => {
+                            if (t.plan)
+                                t.plan.approved = approved;
+                        });
+                        planInForce = { ...plan, approved };
+                        sink.event('plan-approved', { version: planVersion, by: approved.by, ...(approved.note ? { note: approved.note } : {}) }, `plan ${planVersion} approved ${asks ? 'by the operator' : `by the runner — ${why}`}${approved.note ? `, with a note` : ''}`);
+                        planning = false;
+                        message = planApprovedMessage(approved);
+                    }
+                }
+                await record(tag.toUpperCase().replace(/-/g, ' '), message);
+                await pacer.throttleSend();
+                const before = await transport.sendAndConfirm(message);
+                const next = await transport.waitForReply(before);
+                await saveReply(tag, next);
+                lastMarkdown = next.markdown;
+                await pacer.settle();
+                continue;
+            }
             if (!blocked && reply.steps.length > 0)
                 earlyBlocks = 0;
             /*
@@ -2279,8 +2400,12 @@ export async function runTask(transport, session, task, deps) {
                  * usually lost the assignment, said "above": it is given again rather than told nothing ran (live run 2026-10-04).
                  */
                 const message = task.continuing
-                    ? 'Not yet: this task is being continued, and nothing has run since. The assignment is this one, unchanged:\n\n' +
+                    ? `Not yet: this task is being continued, and nothing has run since. The assignment is this one${task.continuing.instruction ? '' : ', unchanged'}:\n\n` +
                         `${task.prompt.length > 6000 ? `${task.prompt.slice(0, 6000)}…` : task.prompt}\n\n` +
+                        // With the operator's new prompt, when there is one: the reason the task is being carried on at all.
+                        (task.continuing.instruction
+                            ? `With the operator's new instruction, which wins where the two disagree:\n\n${task.continuing.instruction.length > 6000 ? `${task.continuing.instruction.slice(0, 6000)}…` : task.continuing.instruction}\n\n`
+                            : '') +
                         'Carry on from where it stopped: send your next step now with status "continue", for example a command that shows ' +
                         'the state of the files the task works on. A task may end "blocked" only after steps that ran.'
                     : 'Not yet: nothing has been run in this task. You do not need to operate anything yourself — this runner executes ' +
@@ -2522,6 +2647,33 @@ export async function runTask(transport, session, task, deps) {
                     });
                 }
             }
+            /*
+             * The planning phase changes nothing: what a round changed is put back before the chat reads the
+             * results, as for a read-only task, and the chat is told. A reminder after many rounds that the
+             * plan is what ends the phase.
+             */
+            if (planning) {
+                planningRounds += 1;
+                if (planEnforced) {
+                    const check = await enforceScope(repoDirOf(session), [], true).catch(() => null);
+                    if (check && (check.outside.length > 0 || check.failed.length > 0)) {
+                        sink.event('plan-change-reverted', { iteration: iterations, reverted: check.reverted, failed: check.failed }, `changed in the planning phase, put back: ${check.reverted.join(', ') || '(none)'}`, 'warn');
+                        runnerNotes.push(`This is the planning phase, and nothing may change yet: the runner put back ${check.reverted.length > 0 ? check.reverted.join(', ') : 'nothing it could'}` +
+                            `${check.failed.length > 0 ? ` and could not put back ${check.failed.map((f) => f.path).join(', ')}` : ''}. Read, then send the plan.`);
+                    }
+                }
+                if (planningRounds === PLAN_NUDGE_AFTER)
+                    runnerNotes.push(planNudge(planningRounds));
+            }
+            /*
+             * What the operator wrote while the task works (2026-10-14: like Claude Code, the user can say more
+             * while it runs): it goes out with this report, and is marked sent.
+             */
+            const fromOperator = await store.takeUnsentNotes(session.id, task.id).catch(() => []);
+            if (fromOperator.length > 0) {
+                runnerNotes.push(operatorNotesSection(fromOperator, true));
+                sink.event('operator-note-sent', { notes: fromOperator.length, with: 'report', iteration: iterations }, `${fromOperator.length} note(s) from the operator go out with this report`);
+            }
             await guardInputs(iterations);
             // --- report back ---------------------------------------------------------------
             const report = await writeReport(results, {
@@ -2791,52 +2943,106 @@ export async function runSession(sessionId, deps) {
              */
             const retriesAllowed = cfg.limits.retryBlockedInFreshChat ?? 0;
             let retried = 0;
-            while (outcome.status === 'blocked' && retried < retriesAllowed && !deps.signal?.aborted && !(outcome.stopCode && NOT_THE_CHATS.includes(outcome.stopCode))) {
-                retried += 1;
+            /*
+             * Keep going until it is done (operator's request, 2026-10-14: "like Claude Code — the work does not stop
+             * until the task is ready, and the limits keep it from looping for ever"). A task stopped by a limit from
+             * the settings — messages, minutes, the reply wait, replies in the wrong shape, rounds of fixing checks or
+             * review findings — is carried on at once in its own chat, from where it got to, as "Continue" would, up
+             * to `limits.autoContinue` times; that count is the bound on the whole, so a task gets at most
+             * (autoContinue + 1) × maxIterations messages and as many × maxRunMinutes. Not a task the operator
+             * stopped, not one that blocked with nothing to do (that goes to a fresh chat below, then to a person),
+             * and not when a pause or Stop was asked for.
+             */
+            const autoAllowed = Math.max(0, cfg.limits.autoContinue ?? 0);
+            let autoContinued = 0;
+            const carriedOnAtOnce = async () => {
+                if (autoContinued >= autoAllowed || deps.signal?.aborted || deps.shouldPause?.())
+                    return false;
+                const now = (await store.getSession(sessionId))?.tasks.find((x) => x.id === task.id);
+                if (!now || !now.limit || now.status === 'aborted' || !isContinuable(now))
+                    return false;
+                autoContinued += 1;
                 bus.publish({
                     sessionId,
                     taskId: task.id,
-                    type: 'task-retry-fresh-chat',
+                    type: 'task-auto-continue',
                     level: 'warn',
-                    message: `"${task.title}" ended blocked; running it again in a fresh conversation (${retried} of ${retriesAllowed})`,
-                    data: { attempt: retried, of: retriesAllowed, reason: outcome.reason },
+                    message: `"${task.title}" stopped at ${now.limit.setting} (${now.limit.value}); carrying it on in its own chat, from where it got to (${autoContinued} of ${autoAllowed})`,
+                    data: { setting: now.limit.setting, value: now.limit.value, time: autoContinued, of: autoAllowed, status: now.status },
                 });
-                await store.rerunTask(sessionId, task.id, {});
-                // The conversation pointer is dropped, so the next message opens a new chat, registers
-                // it and sends the contract again. The old chat stays where it is, readable.
-                session = await store.updateSession(sessionId, (s) => {
-                    s.chat = undefined;
-                    s.contractSent = false;
-                    // Marked, not counted: how many retries this run made is read back from the marks
-                    // (`freshRetriesOfLatestRun`), so a later run cannot add to an earlier one's count.
-                    const again = s.tasks.find((x) => x.id === task.id);
-                    if (again)
-                        again.freshRetry = true;
-                });
-                await chat.newChat();
-                /*
-                 * The picker belongs to the conversation, so a new conversation has lost the choice.
-                 *
-                 * The model is applied once, before the first task, because that is where the
-                 * conversation is opened — and this is the other place one is opened, so it has to be
-                 * applied again here. Without it a session that asked for a particular model ran its
-                 * retries on whatever the chat opens on, which is "Auto", and the record went on saying
-                 * it was the model the session asked for. The review has always done this for its own
-                 * fresh conversations a few hundred lines up; this path simply never did.
-                 */
-                const freshModel = await applySessionModel(chat, session, bus, cfg, store, deps.models);
-                if (effectiveModels(session, cfg).model) {
+                await store.continueTask(sessionId, task.id);
+                session = (await store.getSession(sessionId));
+                const again = session.tasks.find((x) => x.id === task.id);
+                if (!again)
+                    return false;
+                outcome = await runTask(chat, session, again, deps);
+                ran += 1;
+                return true;
+            };
+            for (;;) {
+                while (outcome.status === 'blocked' && retried < retriesAllowed && !deps.signal?.aborted && !(outcome.stopCode && NOT_THE_CHATS.includes(outcome.stopCode))
+                    // A task a limit stopped is carried on where it is, with its work, not started over in a fresh chat.
+                    && !(autoContinued < autoAllowed && !!(await store.getSession(sessionId))?.tasks.find((x) => x.id === task.id)?.limit)) {
+                    retried += 1;
+                    bus.publish({
+                        sessionId,
+                        taskId: task.id,
+                        type: 'task-retry-fresh-chat',
+                        level: 'warn',
+                        message: `"${task.title}" ended blocked; running it again in a fresh conversation (${retried} of ${retriesAllowed})`,
+                        data: { attempt: retried, of: retriesAllowed, reason: outcome.reason },
+                    });
+                    await store.rerunTask(sessionId, task.id, {});
+                    // The conversation pointer is dropped, so the next message opens a new chat, registers
+                    // it and sends the contract again. The old chat stays where it is, readable.
                     session = await store.updateSession(sessionId, (s) => {
-                        s.modelInUse = freshModel.current;
+                        s.chat = undefined;
+                        s.contractSent = false;
+                        // Marked, not counted: how many retries this run made is read back from the marks
+                        // (`freshRetriesOfLatestRun`), so a later run cannot add to an earlier one's count.
+                        const again = s.tasks.find((x) => x.id === task.id);
+                        if (again)
+                            again.freshRetry = true;
                     });
+                    await chat.newChat();
+                    /*
+                     * The picker belongs to the conversation, so a new conversation has lost the choice.
+                     *
+                     * The model is applied once, before the first task, because that is where the
+                     * conversation is opened — and this is the other place one is opened, so it has to be
+                     * applied again here. Without it a session that asked for a particular model ran its
+                     * retries on whatever the chat opens on, which is "Auto", and the record went on saying
+                     * it was the model the session asked for. The review has always done this for its own
+                     * fresh conversations a few hundred lines up; this path simply never did.
+                     */
+                    const freshModel = await applySessionModel(chat, session, bus, cfg, store, deps.models);
+                    if (effectiveModels(session, cfg).model) {
+                        session = await store.updateSession(sessionId, (s) => {
+                            s.modelInUse = freshModel.current;
+                        });
+                    }
+                    if (freshModel.refused)
+                        throw new Error(freshModel.refused);
+                    const fresh = session.tasks.find((x) => x.id === task.id);
+                    if (!fresh)
+                        break;
+                    outcome = await runTask(chat, session, fresh, deps);
+                    ran += 1;
                 }
-                if (freshModel.refused)
-                    throw new Error(freshModel.refused);
-                const fresh = session.tasks.find((x) => x.id === task.id);
-                if (!fresh)
+                if (!(await carriedOnAtOnce()))
                     break;
-                outcome = await runTask(chat, session, fresh, deps);
-                ran += 1;
+            }
+            if (autoContinued > 0) {
+                bus.publish({
+                    sessionId,
+                    taskId: task.id,
+                    type: 'task-auto-continue-ended',
+                    level: outcome.status === 'done' ? 'info' : 'warn',
+                    message: outcome.status === 'done'
+                        ? `"${task.title}" done after being carried on ${autoContinued} time(s) on its own`
+                        : `"${task.title}" ended ${outcome.status} after being carried on ${autoContinued} time(s) on its own${autoContinued >= autoAllowed ? ` — limits.autoContinue (${autoAllowed}) reached` : ''}`,
+                    data: { times: autoContinued, of: autoAllowed, status: outcome.status },
+                });
             }
             if (retried > 0) {
                 bus.publish({