copilot-operator 0.1.42 → 0.1.43

package/dist/src/orchestrator/taskRunner.js

@@ -39,7 +39,7 @@ 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';
@@ -47,6 +47,7 @@ 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';
@@ -1399,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,
@@ -1440,7 +1443,12 @@ export async function runTask(transport, session, task, deps) {
             ...(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;
         });
@@ -2657,6 +2665,15 @@ export async function runTask(transport, session, task, deps) {
                 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, {
@@ -2926,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({

package/dist/src/plan/brief.js

@@ -796,7 +796,16 @@ Skipped entirely when every task ended **"done"**: say so in one line and go to
 
 Otherwise: diagnose first, propose second, and say which kind of proposal it is.
 
-**Ask for the exports**, with the record message from the script. Every row on \`/history\` carries
+**The quickest way to what happened is the operator's own report.** On \`/\`, the workbench, they choose
+the task or its session, press **"Ask Kerrigan"**, write what they saw and want, and press **"Copy for
+Kerrigan"**: you get every task with its id, how it ended and why, what it changed, and their words,
+with the form of the answer. Answer it with **changes** to those sessions — a task carried on with your
+prompt (\`continue\`), a done one given a new prompt (\`newPrompt\`), one started over (\`runAgain\`),
+undone (\`undo\`), accepted as done (\`accept\`), a task added, edited or removed — not with a new plan,
+which would make copies in new chats. They paste your whole answer under **"Her answer"**, press **"Check
+her answer"**, read each change in words, and **"Make the {n} change(s)"**; nothing starts by itself.
+
+**When you need more than that, ask for the exports**, with the record message from the script. Every row on \`/history\` carries
 three links, each for that one task:
 
 - **"plan"** — the sessions and tasks as they are now, in this format, with the edits made in the
@@ -812,7 +821,7 @@ three links, each for that one task:
 **"save the log"** on the same row writes the runner's log of the latest attempt onto the
 operator's Desktop and opens Explorer with the file selected, ready to drag into this chat;
 **"save this attempt's log"** does the same for an earlier one. **"What happened"** unfolds the
-whole story under the row without saving anything. For a whole run rather than one task, it is **"Download everything as JSON"** on \`/\`:
+whole story under the row without saving anything. For a whole run rather than one task, it is **"Download everything as JSON"** on \`/sessions\`:
 one file with every step, exit code, summary, review and commit of those sessions.
 
 **Read \`whyItFailed\` first**, then the last rounds. The failure words: \`blocked\` — the chat
@@ -830,7 +839,11 @@ 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:
+  or the chat did the wrong thing and the checks caught it. **Carry the task on with it first**: it keeps
+  what the failed attempt did, in its own chat and branch, and the chat is told how it ended and why.
+  Give the text, as a \`continue\` change, or for the operator to write on \`/\`: choose the task, put
+  the text in the chat box on the right, press **"Continue with this"**, then start it from the panel that
+  opens. Only when the earlier work should be thrown away, give the whole replacement text, then:
   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. Under **"What is next"**, press **"Continue: run the {n} queued task(s) in {s} session(s)"**
@@ -850,7 +863,10 @@ in those words, every time:
   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"**.
+  that task and every task after it is **"Run again from here"**. On \`/\`, **"Undo…"** on the task offers
+  **"Undo only this task"** — its work taken out of the session's branch, what came after it kept — and
+  **"Go back to before this task"** — it and the tasks after it queued again, nothing started. A task the
+  operator finished by hand is **"Accept as done"**.
 - **A change to the bot.** No wording fixes it: the shell the task needs is not on the machine,
   the claim cannot be written as any of the \`expect\` kinds in the checks table above, the runner
   never picked up what the chat attached, the review did not run at all. Say **this is a change
@@ -936,17 +952,20 @@ answer means, and what you do on it:
    for a criterion that is only **claimed**, because it is the cheapest: it changes nothing and turns
    "claimed only" into "proven" or into a real failure you can then fix. Write it as a plan in this
    format.
-2. **Change a task and run it again** — when the work is right for the task but the task was
-   asked wrongly. Give the whole replacement prompt. On \`/history\`:
+2. **Give a done task a new prompt** — when the work is right as far as it goes but more is needed,
+   or it was asked wrongly. A \`newPrompt\` change, or on \`/\`: the task, its chat box, **"Queue with
+   this new prompt"** — it builds on what the task did. To start it over instead: on \`/history\`,
    **"Fix the prompt and queue it again"** on that row, replace the text, **"Save and queue
    again"**, then continue the run.
 3. **Put the repository back and solve it differently** — when the approach is wrong rather than
-   the wording, and building on it would be building on the wrong thing. **"Restore"** on the
+   the wording, and building on it would be building on the wrong thing. An \`undo\` change, or on
+   \`/\` **"Undo…"**: **"Undo only this task"** takes its work out and keeps what came after;
+   **"Go back to before this task"** queues it and every one after it again. **"Restore"** on the
    task card puts the code back to before that task; **"Run again from here"** puts it back and
    re-runs that task and every one after it. Say what will be lost.
-4. **A new session of tasks** — when what is missing was never asked for by any task, so there
-   is nothing to fix and something to add. Write it as a plan in this format, for
-   **"Create the sessions and tasks"**.
+4. **More tasks** — when what is missing was never asked for by any task, so there is nothing to
+   fix and something to add. In the same session, as \`addTask\` changes; as a new session, a plan
+   in this format, for **"Create the sessions and tasks"**.
 `.trim();
 const PHASE3_BG = `
 ## Фаза 3 — задача не завърши готова
@@ -956,7 +975,16 @@ const PHASE3_BG = `
 
 Иначе: първо диагноза, после предложение, и всеки път казвай от кой вид е предложението.
 
-**Поискай файловете**, със съобщението за записа от сценария. Всеки ред в \`/history\` носи три
+**Най-бързият път до случилото се е отчетът на самия оператор.** В \`/\`, работното място, той избира
+задачата или сесията ѝ, натиска **„Попитай Кериган“**, пише какво е видял и какво иска и натиска
+**„Копирай за Кериган“**: получаваш всяка задача с id-то ѝ, как е завършила и защо, какво е променила, и
+думите му, с формата на отговора. Отговори с **промени** по тези сесии — задача, продължена с твоя prompt
+(\`continue\`), готова с нов prompt (\`newPrompt\`), пусната отначало (\`runAgain\`), отменена (\`undo\`),
+приета като готова (\`accept\`), добавена, редактирана или премахната задача — а не с нов план, който би
+направил копия в нови чатове. Той поставя целия ти отговор под **„Нейният отговор“**, натиска **„Провери
+отговора ѝ“**, чете всяка промяна с думи и **„Направи промените ({n})“**; нищо не тръгва само.
+
+**Когато ти трябва повече, поискай файловете**, със съобщението за записа от сценария. Всеки ред в \`/history\` носи три
 връзки, всяка за точно тази задача:
 
 - **„план“** — сесиите и задачите, както са сега, в този формат, с редакциите от интерфейса.
@@ -973,7 +1001,7 @@ const PHASE3_BG = `
 оператора и отваря Explorer с избран файл, готов за влачене в този чат; **„запази log-а на този
 опит“** прави същото за по-ранен. **„Какво се случи“** разгъва цялата история под реда, без да се
 записва нищо. За цяло пускане, а не
-за една задача, е **„Изтегли всичко като JSON“** в \`/\`: един файл с всяка стъпка, код на изход,
+за една задача, е **„Изтегли всичко като JSON“** в \`/sessions\`: един файл с всяка стъпка, код на изход,
 обяснение, рецензия и комит на тези сесии.
 
 **Чети първо \`whyItFailed\`**, после последните кръгове. Думите за провал: \`blocked\` — чатът
@@ -992,7 +1020,10 @@ const PHASE3_BG = `
 - **Нов prompt.** Текстът на задачата е бил двусмислен, път или порт е грешен, ниво 2 е
   забранявало това, което задачата иска, проверка е питала git индекса за файл, който runner-ът
   още не е комитнал, или чатът е направил грешното нещо и проверките са го хванали. Дай целия
-  нов текст, после:
+  текст. **Първо продължи задачата с него**: пази каквото е свършил провалилият се опит, в своя чат и
+  клон, а чатът научава как е завършил и защо. Дай текста като промяна \`continue\` или за оператора в
+  \`/\`: задачата, текстът в полето на чата вдясно, **„Продължи с това“**, после пускане от панела,
+  който се отваря. Само когато по-ранната работа трябва да се изхвърли, дай целия нов текст, после:
   1. В \`/history\`, в изгледа **„Поток“**, натисни **„Поправи prompt-а и върни в опашката“** на този ред.
   2. Замени текста с горния и натисни **„Запази и върни в опашката“**.
   3. Под **„Какво следва“** натисни **„Продължи: пусни {n} чакащи задачи в {s} сесии“** (пише
@@ -1012,7 +1043,10 @@ const PHASE3_BG = `
   Когато провал се покаже, докато пускането още върви, **„Пауза след тази задача“** задържа
   останалото, докато го разбереш.
   Връщането на хранилището отпреди задачата е **„Върни“**; връщането му плюс ново изпълнение на
-  тази задача и всички след нея е **„Пусни отново оттук“**.
+  тази задача и всички след нея е **„Пусни отново оттук“**. В \`/\` **„Отмени…“** на задачата предлага
+  **„Отмени само тази задача“** — работата ѝ се изважда от клона на сесията, каквото е след нея остава — и
+  **„Върни отпреди тази задача“** — тя и задачите след нея отново на опашката, без пускане. Задача,
+  довършена ръчно от оператора, е **„Приеми като готова“**.
 - **Промяна по бота.** Никакви думи не го оправят: обвивката, която задачата иска, я няма на
   машината, твърдението не се изразява с нито един от видовете \`expect\` от таблицата с
   проверките по-горе, runner-ът изобщо не е взел това, което чатът е прикачил, рецензията не се
@@ -1099,17 +1133,20 @@ const PHASE4_BG = `
    я първа за критерий, който е само **твърдение**, защото е най-евтината: не променя нищо и превръща
    „само твърдение“ в „доказано“ или в истински провал, който после можеш да поправиш. Напиши я като
    план в този формат.
-2. **Промени задача и я пусни отново** — когато работата е правилна за задачата, но задачата е
-   била поискана грешно. Дай целия заместващ prompt. В \`/history\`:
+2. **Дай на готова задача нов prompt** — когато работата е правилна дотук, но трябва още, или е била
+   поискана грешно. Промяна \`newPrompt\` или в \`/\`: задачата, полето на чата, **„На опашката с този
+   нов prompt“** — надгражда свършеното. За да тръгне отначало: в \`/history\`
    **„Поправи prompt-а и върни в опашката“** на този ред, замени текста,
    **„Запази и върни в опашката“**, после продължи изпълнението.
 3. **Върни хранилището и реши иначе** — когато грешен е подходът, а не формулировката, и да се
-   стъпва върху него значи да се стъпва върху грешното нещо. **„Върни“** на картата на задачата
+   стъпва върху него значи да се стъпва върху грешното нещо. Промяна \`undo\` или в \`/\` **„Отмени…“**:
+   **„Отмени само тази задача“** изважда работата ѝ и пази каквото е след нея; **„Върни отпреди тази
+   задача“** слага нея и всяка след нея отново на опашката. **„Върни“** на картата на задачата
    връща кода отпреди тази задача; **„Пусни отново оттук“** го връща и пуска пак нея и всяка след
    нея. Кажи какво ще се загуби.
-4. **Нова сесия със задачи** — когато липсващото никога не е било поискано от никоя задача, така че
-   няма какво да се поправя, а има какво да се добави. Напиши я като план в този формат, за
-   **„Създай сесиите и задачите“**.
+4. **Още задачи** — когато липсващото никога не е било поискано от никоя задача, така че няма какво
+   да се поправя, а има какво да се добави. В същата сесия — като промени \`addTask\`; като нова сесия —
+   план в този формат, за **„Създай сесиите и задачите“**.
 `.trim();
 /**
  * The operator's own part, verbatim — or, while there is none, the interview that produces it.

package/dist/src/plan/changes.js

@@ -0,0 +1,217 @@
+/**
+ * Kerrigan's answer about work that already exists (operator's request, 2026-10-14: "no dead end — the user
+ * tells Kerrigan what happened and she proposes how to go on; even when the tasks are done she may judge the
+ * implementation wrong and ask for more"). A plan only ever made new sessions, so everything she advised about
+ * a session that had run had to be done by hand, or became a copy of it in a new chat.
+ *
+ * Two halves, both plain text so they work with any chat: `kerriganReport` writes what happened — each session
+ * and task with its id, how it ended and why, what it changed — together with the operator's note and the exact
+ * form of the answer; `checkChanges` reads her answer, a list of changes to those sessions and tasks, against
+ * them as they are now, and says in words what each would do before anything is done. The service applies them
+ * one by one through the same paths the buttons use, so a change is held to the same rules as a click.
+ */
+import { z } from 'zod';
+import { TaskInput, extractJson } from './schema.js';
+import { canFollowUp, clipText, isContinuable } from '../session/model.js';
+const SessionRef = z.string({ error: 'Each change names its "session": the id from the report (s-…), or its exact name.' }).trim().min(1);
+const TaskRef = z.union([z.string().trim().min(1), z.number().int().positive()], {
+    error: 'Each change names its "task": the id from the report (t-…), its number in the session, or its exact title.',
+});
+export const ChangeSchema = z.discriminatedUnion('op', [
+    z.object({ op: z.literal('addTask'), session: SessionRef, after: TaskRef.optional(), task: TaskInput }),
+    z.object({
+        op: z.literal('editTask'),
+        session: SessionRef,
+        task: TaskRef,
+        title: z.string().trim().min(3).max(120).optional(),
+        prompt: z.string().trim().min(30, 'A new prompt needs a real instruction, not a few words.').optional(),
+        checks: TaskInput.shape.checks.optional(),
+        scope: TaskInput.shape.scope.optional(),
+    }),
+    z.object({ op: z.literal('removeTask'), session: SessionRef, task: TaskRef }),
+    z.object({ op: z.literal('continue'), session: SessionRef, task: TaskRef, instruction: z.string().trim().min(10, 'Say what to do now: "instruction" is the new prompt the task carries on with.') }),
+    z.object({ op: z.literal('newPrompt'), session: SessionRef, task: TaskRef, prompt: z.string().trim().min(30, 'A new prompt needs a real instruction, not a few words.') }),
+    z.object({ op: z.literal('runAgain'), session: SessionRef, task: TaskRef, prompt: z.string().trim().min(30).optional() }),
+    z.object({ op: z.literal('undo'), session: SessionRef, task: TaskRef, how: z.enum(['this', 'back'], { error: '"how" is "this" (take only this task\'s work out) or "back" (go back to before it, and queue the tasks after it too).' }) }),
+    z.object({ op: z.literal('accept'), session: SessionRef, task: TaskRef, note: z.string().trim().optional() }),
+    z.object({ op: z.literal('note'), session: SessionRef, task: TaskRef, text: z.string().trim().min(1) }),
+], {
+    error: (i) => (i.code === 'invalid_union' ? '"op" must be one of addTask, editTask, removeTask, continue, newPrompt, runAgain, undo, accept, note.' : undefined),
+});
+export const ChangesSchema = z.object({
+    version: z.literal(1, 'Set "version": 1.'),
+    notes: z.string().trim().default(''),
+    changes: z.array(ChangeSchema).min(1, 'An answer with "changes" needs at least one.'),
+});
+/** Whether the pasted text is an answer with changes rather than a plan of new sessions. */
+export function looksLikeChanges(text) {
+    try {
+        const raw = JSON.parse(extractJson(text ?? ''));
+        return !!raw && typeof raw === 'object' && Array.isArray(raw.changes);
+    }
+    catch {
+        return false;
+    }
+}
+const RUNNING = ['running', 'waiting-approval'];
+function findSession(sessions, ref) {
+    return sessions.find((s) => s.id === ref) ?? sessions.find((s) => s.name === ref) ?? sessions.find((s) => s.name.toLowerCase() === ref.toLowerCase());
+}
+function findTask(session, ref) {
+    if (typeof ref === 'number' || /^\d+$/.test(ref))
+        return session.tasks[Number(ref) - 1];
+    return session.tasks.find((t) => t.id === ref) ?? session.tasks.find((t) => t.title === ref) ?? session.tasks.find((t) => t.title.toLowerCase() === ref.toLowerCase());
+}
+/** Reads Kerrigan's answer and finds each change against the sessions as they are now. Nothing is changed. */
+export function checkChanges(text, sessions) {
+    let raw;
+    try {
+        raw = JSON.parse(extractJson(text ?? ''));
+    }
+    catch (e) {
+        return { ok: false, warnings: [], issues: [{ path: '', message: `This is not valid JSON: ${e.message}.` }] };
+    }
+    const parsed = ChangesSchema.safeParse(raw);
+    if (!parsed.success) {
+        return { ok: false, warnings: [], issues: parsed.error.issues.map((i) => ({ path: i.path.map((p) => (typeof p === 'number' ? `[${p}]` : `.${String(p)}`)).join('').replace(/^\./, ''), message: i.message })) };
+    }
+    const issues = [];
+    const warnings = [];
+    const changes = [];
+    parsed.data.changes.forEach((change, index) => {
+        const path = `changes[${index}]`;
+        const session = findSession(sessions, change.session);
+        if (!session) {
+            issues.push({ path: `${path}.session`, message: `No session "${change.session}". Use the id from the report (s-…) or the session's exact name.` });
+            return;
+        }
+        const base = { index, change, sessionId: session.id, sessionName: session.name };
+        if (change.op === 'addTask') {
+            const after = change.after !== undefined ? findTask(session, change.after) : undefined;
+            if (change.after !== undefined && !after) {
+                issues.push({ path: `${path}.after`, message: `Session "${session.name}" has no task "${change.after}" to put the new one after.` });
+                return;
+            }
+            changes.push({ ...base, says: `add task "${change.task.title}" to "${session.name}"${after ? `, after "${after.title}"` : ', at the end'}, queued` });
+            return;
+        }
+        const task = findTask(session, change.task);
+        if (!task) {
+            issues.push({ path: `${path}.task`, message: `Session "${session.name}" has no task "${change.task}". Use the id from the report (t-…), its number, or its exact title.` });
+            return;
+        }
+        const named = { ...base, taskId: task.id, taskTitle: task.title };
+        const refuse = (message) => {
+            issues.push({ path: `${path}.op`, message: `"${task.title}" in "${session.name}" is ${task.status}: ${message}` });
+        };
+        if (RUNNING.includes(task.status))
+            return refuse('it is running now; nothing can be changed on it until it stops.');
+        switch (change.op) {
+            case 'editTask':
+                if (task.status !== 'queued')
+                    return refuse('only a queued task is edited; for one that ran use "runAgain" with a "prompt", "continue" or "newPrompt".');
+                changes.push({ ...named, says: `edit "${task.title}": ${['title', 'prompt', 'checks', 'scope'].filter((k) => change[k] !== undefined).join(', ') || 'nothing'}` });
+                return;
+            case 'removeTask':
+                if (task.status !== 'queued')
+                    return refuse('only a queued task is removed; a task that ran keeps its record.');
+                changes.push({ ...named, says: `remove the queued task "${task.title}"` });
+                return;
+            case 'continue':
+                if (!isContinuable(task) && !canFollowUp(task))
+                    return refuse('only a task that failed, blocked or stopped is carried on; for a done one use "newPrompt".');
+                changes.push({ ...named, says: `carry "${task.title}" on in its own chat and branch, from where it got to, with the new prompt` });
+                return;
+            case 'newPrompt':
+                if (task.status !== 'done')
+                    return refuse('"newPrompt" builds on a done task\'s work; for a failed one use "continue".');
+                changes.push({ ...named, says: `give the done task "${task.title}" a new prompt that builds on its work, queued` });
+                return;
+            case 'runAgain':
+                if (task.status === 'queued')
+                    return refuse('it is queued already; use "editTask" to change it.');
+                changes.push({ ...named, says: `run "${task.title}" again from where it first started${change.prompt ? ', with a new prompt' : ''}, queued` });
+                return;
+            case 'undo':
+                if (task.status === 'queued' || !task.startedAt)
+                    return refuse('it has not run since it was queued; there is nothing of it to undo.');
+                changes.push({ ...named, says: change.how === 'this' ? `undo only "${task.title}": its work taken out, the tasks after it kept; it is queued again` : `go back to before "${task.title}": it and the tasks after it queued again` });
+                return;
+            case 'accept':
+                if (!['failed', 'blocked', 'limit-reached', 'aborted'].includes(task.status))
+                    return refuse('only a task that ended without being done is accepted as done.');
+                changes.push({ ...named, says: `accept "${task.title}" as done${change.note ? ', with a note' : ''}` });
+                return;
+            case 'note':
+                if (task.status !== 'queued')
+                    warnings.push(`The note for "${task.title}" (${task.status}) goes out only when it runs again.`);
+                changes.push({ ...named, says: `a note to the chat for "${task.title}"` });
+                return;
+        }
+    });
+    if (issues.length > 0)
+        return { ok: false, issues, warnings };
+    return { ok: true, notes: parsed.data.notes, changes, warnings };
+}
+// --- the report ------------------------------------------------------------------------------
+const clip = (s, n) => (clipText(s, n) ?? '').replace(/\s+/g, ' ').trim();
+function taskLines(task, index) {
+    const out = [`${index + 1}. "${task.title}" — id ${task.id} — ${task.status}${(task.attempt ?? 1) > 1 ? `, attempt ${task.attempt}` : ''}`];
+    if (task.accepted)
+        out.push(`   accepted as done by the operator (it had ended ${task.accepted.was})${task.accepted.note ? `: ${clip(task.accepted.note, 300)}` : ''}`);
+    const undone = task.attempts?.at(-1)?.undone;
+    if (task.status === 'queued' && undone)
+        out.push(`   its last attempt was undone by the operator (${undone.how === 'this' ? 'only its work taken out' : 'back to before it'})`);
+    if (task.continuing?.instruction)
+        out.push(`   carried on with the operator's prompt: ${clip(task.continuing.instruction, 400)}`);
+    if (task.status === 'queued')
+        out.push(`   prompt: ${clip(task.prompt, 500)}`);
+    if (task.summary && task.status !== 'queued')
+        out.push(`   summary: ${clip(task.summary, 600)}`);
+    if (task.reason && task.reason !== task.summary && task.status !== 'done')
+        out.push(`   why it stopped: ${clip(task.reason, 600)}`);
+    const failed = (task.checkResults ?? []).filter((c) => !c.passed);
+    if (failed.length > 0)
+        out.push(`   checks that did not pass: ${failed.slice(0, 6).map((c) => `${c.name} (${clip(c.detail, 160)})`).join('; ')}`);
+    if (task.review?.verdict) {
+        const findings = (task.review.findings ?? []).slice(0, 5).map((f) => `${clip(f.what, 200)}${f.where ? ` [${clip(f.where, 80)}]` : ''}`);
+        out.push(`   review: ${task.review.verdict}${findings.length > 0 ? ` — ${findings.join('; ')}` : ''}`);
+    }
+    const files = (task.vcs?.files ?? []).map((f) => f.path);
+    if (files.length > 0)
+        out.push(`   changed: ${files.slice(0, 25).join(', ')}${files.length > 25 ? ` and ${files.length - 25} more` : ''}`);
+    if (task.vcs?.branch)
+        out.push(`   branch ${task.vcs.branch}${task.vcs.commit ? ` at ${task.vcs.commit.slice(0, 8)}` : ''}`);
+    const notes = task.notes ?? [];
+    if (notes.length > 0)
+        out.push(`   operator's notes: ${notes.slice(-3).map((n) => clip(n.text, 200)).join(' | ')}`);
+    return out;
+}
+/**
+ * What happened, for Kerrigan: the sessions, each task with its id, how it ended and why, and what it changed;
+ * the operator's note; and the exact form of the answer. Plain text, for any chat.
+ */
+export function kerriganReport(sessions, opts = {}) {
+    const only = new Set(opts.taskIds ?? []);
+    const lines = [
+        '# What happened — for Kerrigan',
+        '',
+        `The operator sends you the state of their work as copilot-operator recorded it (${opts.at ?? new Date().toISOString()}), and asks you to look at it`,
+        'and propose how to go on — whether the tasks failed, stopped, or are done but not what was meant.',
+        '',
+    ];
+    if (opts.note?.trim())
+        lines.push('## The operator says', '', opts.note.trim(), '');
+    for (const s of sessions) {
+        const vcs = s.vcs?.enabled ? `${s.vcs.branchMode === 'per-task' ? 'a branch per task' : 'one branch for the session, a commit per task'} in ${s.vcs.repoDir || '(no folder)'}` : 'no version control';
+        lines.push(`## Session "${s.name}" — id ${s.id}`, '', `${vcs}; ${s.onFailure === 'continue' ? 'independent tasks' : 'one chain: a failed task stops the ones after it'}.`, '');
+        s.tasks.forEach((t, i) => {
+            if (only.size > 0 && !only.has(t.id))
+                return;
+            lines.push(...taskLines(t, i));
+        });
+        lines.push('');
+    }
+    lines.push('## How to answer', '', 'First tell the operator, in their language and in a few sentences, what you think happened and what you propose.', 'Then give the changes as one JSON object in a ```json block, which the operator pastes on the import page;', 'it shows each change in words before anything is done. Name sessions and tasks by the ids above.', '', '```json', '{"version": 1, "notes": "why, in one or two sentences", "changes": [', '  {"op": "continue", "session": "s-…", "task": "t-…", "instruction": "what to do now — the task goes on from where it got to, in its own chat and branch"},', '  {"op": "addTask", "session": "s-…", "after": "t-…", "task": {"title": "…", "prompt": "…", "expected": "…", "checks": [], "scope": []}}', ']}', '```', '', 'The changes, one object each:', '- "continue" {task, instruction} — a task that failed, blocked or stopped goes on from where it got to, with your prompt added to its own.', '- "newPrompt" {task, prompt} — a done task gets a new prompt that builds on its work (more to do, or done wrong).', '- "runAgain" {task, prompt?} — a task that ran starts over from where it first started, optionally with a corrected prompt; its earlier work is not used.', '- "undo" {task, how} — "this": only this task\'s work is taken out of the session\'s branch, the tasks after it kept; "back": the branch goes back to before it, and it and the tasks after it are queued again. Nothing is deleted.', '- "accept" {task, note?} — a task that did not end done is accepted as done (for example, the operator finished it by hand).', '- "addTask" {task, after?} — a new task in an existing session, after the task named (else at the end); "task" has the fields of a plan\'s task.', '- "editTask" {task, title?, prompt?, checks?, scope?} — a queued task, changed before it runs.', '- "removeTask" {task} — a queued task that is no longer wanted.', '- "note" {task, text} — information for the chat about a task, sent with its next message.', '', 'Nothing runs by itself after the import: the operator starts the run. For work that belongs in a new session, answer with a plan as before.');
+    return lines.join('\n');
+}

package/dist/src/plan/schema.js

@@ -250,7 +250,7 @@ const TaskVcsInput = z.object({
  * ignored with a warning. See `importPlan`.
  */
 const LegacyMirrorInput = z.object({ enabled: z.boolean().optional(), rootDir: z.string().optional() }).passthrough();
-const TaskInput = z.object({
+export const TaskInput = z.object({
     title: z
         .string()
         .trim()