copilot-operator 0.1.41 → 0.1.43

package/dist/src/plan/brief.js

@@ -309,6 +309,12 @@ const FIELD_ROWS_EN = [
         'no',
         'Overrides the setting above for this one session: give the same name to the sessions that should share a chat, and leave it "" for a session that should have its own.',
     ],
+    [
+        'planMode',
+        'session',
+        'no',
+        'Plan first: "auto" — each task looks at the code read-only and makes a plan, approved by the runner, before it changes anything; "approve" — the same, approved by the operator in a run that asks before each command; "off". Leave it out to follow Settings. Ask when the work is large or the code base is new to the chat.',
+    ],
     [
         'projectDir',
         'session',
@@ -380,6 +386,12 @@ const FIELD_ROWS_BG = [
         'не',
         'Отменя настройката горе само за тази сесия: дай едно и също име на сесиите, които да споделят чат, и остави "" на онази, която да е сама.',
     ],
+    [
+        'planMode',
+        'сесия',
+        'не',
+        'Първо план: "auto" — всяка задача разглежда кода само с четене и прави план, одобрен от runner-а, преди да промени нещо; "approve" — същото, одобрено от оператора при пускане с питане преди всяка команда; "off". Пропусни го, за да следва Настройките. Питай, когато работата е голяма или кодът е непознат за чата.',
+    ],
     [
         'projectDir',
         'сесия',
@@ -784,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
@@ -800,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
@@ -818,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)"**
@@ -838,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
@@ -924,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 — задача не завърши готова
@@ -944,7 +975,16 @@ const PHASE3_BG = `
 
 Иначе: първо диагноза, после предложение, и всеки път казвай от кой вид е предложението.
 
-**Поискай файловете**, със съобщението за записа от сценария. Всеки ред в \`/history\` носи три
+**Най-бързият път до случилото се е отчетът на самия оператор.** В \`/\`, работното място, той избира
+задачата или сесията ѝ, натиска **„Попитай Кериган“**, пише какво е видял и какво иска и натиска
+**„Копирай за Кериган“**: получаваш всяка задача с id-то ѝ, как е завършила и защо, какво е променила, и
+думите му, с формата на отговора. Отговори с **промени** по тези сесии — задача, продължена с твоя prompt
+(\`continue\`), готова с нов prompt (\`newPrompt\`), пусната отначало (\`runAgain\`), отменена (\`undo\`),
+приета като готова (\`accept\`), добавена, редактирана или премахната задача — а не с нов план, който би
+направил копия в нови чатове. Той поставя целия ти отговор под **„Нейният отговор“**, натиска **„Провери
+отговора ѝ“**, чете всяка промяна с думи и **„Направи промените ({n})“**; нищо не тръгва само.
+
+**Когато ти трябва повече, поискай файловете**, със съобщението за записа от сценария. Всеки ред в \`/history\` носи три
 връзки, всяка за точно тази задача:
 
 - **„план“** — сесиите и задачите, както са сега, в този формат, с редакциите от интерфейса.
@@ -961,7 +1001,7 @@ const PHASE3_BG = `
 оператора и отваря Explorer с избран файл, готов за влачене в този чат; **„запази log-а на този
 опит“** прави същото за по-ранен. **„Какво се случи“** разгъва цялата история под реда, без да се
 записва нищо. За цяло пускане, а не
-за една задача, е **„Изтегли всичко като JSON“** в \`/\`: един файл с всяка стъпка, код на изход,
+за една задача, е **„Изтегли всичко като JSON“** в \`/sessions\`: един файл с всяка стъпка, код на изход,
 обяснение, рецензия и комит на тези сесии.
 
 **Чети първо \`whyItFailed\`**, после последните кръгове. Думите за провал: \`blocked\` — чатът
@@ -980,7 +1020,10 @@ const PHASE3_BG = `
 - **Нов prompt.** Текстът на задачата е бил двусмислен, път или порт е грешен, ниво 2 е
   забранявало това, което задачата иска, проверка е питала git индекса за файл, който runner-ът
   още не е комитнал, или чатът е направил грешното нещо и проверките са го хванали. Дай целия
-  нов текст, после:
+  текст. **Първо продължи задачата с него**: пази каквото е свършил провалилият се опит, в своя чат и
+  клон, а чатът научава как е завършил и защо. Дай текста като промяна \`continue\` или за оператора в
+  \`/\`: задачата, текстът в полето на чата вдясно, **„Продължи с това“**, после пускане от панела,
+  който се отваря. Само когато по-ранната работа трябва да се изхвърли, дай целия нов текст, после:
   1. В \`/history\`, в изгледа **„Поток“**, натисни **„Поправи prompt-а и върни в опашката“** на този ред.
   2. Замени текста с горния и натисни **„Запази и върни в опашката“**.
   3. Под **„Какво следва“** натисни **„Продължи: пусни {n} чакащи задачи в {s} сесии“** (пише
@@ -1000,7 +1043,10 @@ const PHASE3_BG = `
   Когато провал се покаже, докато пускането още върви, **„Пауза след тази задача“** задържа
   останалото, докато го разбереш.
   Връщането на хранилището отпреди задачата е **„Върни“**; връщането му плюс ново изпълнение на
-  тази задача и всички след нея е **„Пусни отново оттук“**.
+  тази задача и всички след нея е **„Пусни отново оттук“**. В \`/\` **„Отмени…“** на задачата предлага
+  **„Отмени само тази задача“** — работата ѝ се изважда от клона на сесията, каквото е след нея остава — и
+  **„Върни отпреди тази задача“** — тя и задачите след нея отново на опашката, без пускане. Задача,
+  довършена ръчно от оператора, е **„Приеми като готова“**.
 - **Промяна по бота.** Никакви думи не го оправят: обвивката, която задачата иска, я няма на
   машината, твърдението не се изразява с нито един от видовете \`expect\` от таблицата с
   проверките по-горе, runner-ът изобщо не е взел това, което чатът е прикачил, рецензията не се
@@ -1087,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/importPlan.js

@@ -231,6 +231,8 @@ defaultProjectDir = '') {
             // the standing default, else the session's own.
             s.review = { enabled: planned.review?.enabled !== false, model: (planned.review?.model || defaultReviewModel).trim() };
             s.conversationGroup = group || undefined;
+            if (planned.planMode)
+                s.planMode = planned.planMode;
             s.model = (planned.model || defaultModel).trim() || undefined;
             // The plan's models are kept, and marked as the plan's: Settings outrank them (see `effectiveModels`).
             if (planned.model?.trim())

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()
@@ -348,6 +348,16 @@ const SessionInput = z.object({
      * the same name. Empty means it gets a conversation of its own.
      */
     conversationGroup: z.string().trim().default(''),
+    /**
+     * Plan mode for the session's tasks (see `PlanMode` in session/model.ts): "auto" plans first and goes
+     * on, "approve" plans first and waits for the operator in a run that asks before each command, "off"
+     * does not plan apart. Absent follows Settings.
+     */
+    planMode: z
+        .enum(['off', 'auto', 'approve'], {
+        error: 'planMode must be "off", "auto" (plan first, approved by the runner) or "approve" (plan first, approved by the operator in a run that asks before each command).',
+    })
+        .optional(),
     vcs: VcsInput,
     review: ReviewInput.optional(),
     /**