copilot-operator 0.1.6 → 0.1.8

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

@@ -178,6 +178,19 @@ let OperatorController = class OperatorController {
             throw new NotFoundException('This task has not run yet, or that attempt is not its own.');
         return story;
     }
+    /**
+     * What a task changed: the files between the commit it started from and the one it produced.
+     * `run` picks an earlier attempt. See `taskChanges`.
+     */
+    taskChanges(id, taskId, run) {
+        return this.ops.taskChanges(id, taskId, run?.trim() || undefined).catch(fail);
+    }
+    /** One of those files, before and after. Only a file the task changed can be asked for. */
+    taskChangeFile(id, taskId, path, run) {
+        if (!path)
+            throw new BadRequestException('path is required');
+        return this.ops.taskChangeFile(id, taskId, path, run?.trim() || undefined).catch(fail);
+    }
     taskFiles(id, taskId, run) {
         return this.ops.taskFiles(id, taskId, run);
     }
@@ -729,6 +742,25 @@ __decorate([
     __metadata("design:paramtypes", [String, String, String]),
     __metadata("design:returntype", Promise)
 ], OperatorController.prototype, "taskStory", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/changes'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskChanges", null);
+__decorate([
+    Get('sessions/:id/tasks/:taskId/changes/file'),
+    __param(0, Param('id')),
+    __param(1, Param('taskId')),
+    __param(2, Query('path')),
+    __param(3, Query('run')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String]),
+    __metadata("design:returntype", Promise)
+], OperatorController.prototype, "taskChangeFile", null);
 __decorate([
     Get('sessions/:id/tasks/:taskId/files'),
     __param(0, Param('id')),

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

@@ -36,8 +36,9 @@ function sameFolder(a, b) {
     return a.trim() !== '' && norm(a) === norm(b);
 }
 import { importPlan, plannedSessionSignature, taskSignature } from '../plan/importPlan.js';
-import { commitInterrupted, vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
-import { gitAvailable, repoUnusableReason } from '../vcs/git.js';
+import { readInterruption } from '../session/interruption.js';
+import { commitInterrupted, repoDirOf, vcsPreflight, restorePreview, restoreToBase, sessionBranches } from '../vcs/taskVcs.js';
+import { changedFilesBetween, fileAt, gitAvailable, repoUnusableReason } from '../vcs/git.js';
 import { makeAuthorizer } from '../exec/authorizer.js';
 import { listSelectableDirs, collectFiles, findSelectionConflicts, describeConflicts, DEFAULT_IGNORE_DIRS } from '../context/projectMirror.js';
 import { pickFolder } from './folderPicker.js';
@@ -101,19 +102,23 @@ let OperatorService = class OperatorService {
         if (!session || !task)
             return;
         const vcs = await commitInterrupted(session, task, task.reason ?? 'interrupted', this.bus);
-        const settled = vcs?.commit
-            ? await this.store.updateSession(sessionId, (s) => {
-                const t = s.tasks.find((x) => x.id === taskId);
-                if (!t)
-                    return;
+        const cfg = await this.settings.load();
+        // Where it had got to, from its run folder, so "Continue" can tell the chat exactly that.
+        const interruption = task.runId ? await readInterruption(join(cfg.resolved.runsDir, task.runId)) : null;
+        const settled = await this.store.updateSession(sessionId, (s) => {
+            const t = s.tasks.find((x) => x.id === taskId);
+            if (!t)
+                return;
+            if (interruption)
+                t.interruption = interruption;
+            if (vcs?.commit) {
                 t.vcs = vcs;
                 t.reason = `${t.reason ?? ''} What it had changed is committed on ${vcs.branch} as ${vcs.commit?.slice(0, 8)}.`.trim();
-            })
-            : session;
+            }
+        });
         const ended = settled.tasks.find((t) => t.id === taskId);
         if (!ended)
             return;
-        const cfg = await this.settings.load();
         await writeAttemptRecord(settled, ended, cfg.resolved.runsDir, exportMachine(cfg));
     }
     /** Runs the startup work now, so it does not wait for the first request. */
@@ -314,7 +319,7 @@ let OperatorService = class OperatorService {
      * the text it ran with, and only then is the new text applied. Editing in place would leave
      * the old attempt's summary sitting under a question that was never asked.
      */
-    /** "Continue" on a task that stopped at the runner's limit: same chat, same branch, fresh count. */
+    /** "Continue" on a task that stopped before it finished — its limit, the bot stopping, the operator: same chat, same branch, fresh count. */
     async continueTask(sessionId, taskId) {
         await this.init();
         const task = await this.store.continueTask(sessionId, taskId);
@@ -388,6 +393,78 @@ let OperatorService = class OperatorService {
         return await buildStory(cfg.resolved.runsDir, chosen, view, live);
     }
     /** Files a task produced, so the UI can list reports and downloaded scripts. */
+    /**
+     * What a task changed in the repository: the files, between the commit it started from and the
+     * commit it produced. `runId` picks an earlier attempt. Read from git each time rather than kept
+     * on the record, so what is shown is the repository's own account; the record only says which
+     * two commits to compare.
+     *
+     * There is something to show only when version control was on and the task committed: a task
+     * that changed nothing, or ran with version control off, left no commit to compare, and the
+     * answer says which.
+     */
+    async taskChanges(sessionId, taskId, runId) {
+        const found = await this.changesOf(sessionId, taskId, runId);
+        if ('problem' in found)
+            return { ok: false, problem: found.problem, files: [] };
+        const listed = await changedFilesBetween(found.dir, found.base, found.commit);
+        if (listed.problem)
+            return { ok: false, problem: `the repository no longer has these commits: ${listed.problem}`, files: [] };
+        return { ok: true, repoDir: found.dir, branch: found.branch, base: found.base, commit: found.commit, files: listed.files };
+    }
+    /**
+     * One changed file, before and after, as text. Only a file the task changed can be asked for:
+     * the path is checked against that list, so this cannot be used to read anything else in the
+     * repository's history. A binary file, or one over 2 MB on either side, is said to be so rather
+     * than returned.
+     */
+    async taskChangeFile(sessionId, taskId, path, runId) {
+        const found = await this.changesOf(sessionId, taskId, runId);
+        if ('problem' in found)
+            throw new Error(found.problem);
+        const listed = await changedFilesBetween(found.dir, found.base, found.commit);
+        const file = listed.files.find((f) => f.path === path);
+        if (!file)
+            throw new Error('That file is not one this task changed.');
+        const MAX = 2 * 1024 * 1024;
+        const before = file.status === 'A' ? { bytes: null, tooLarge: false } : await fileAt(found.dir, found.base, file.oldPath ?? file.path, MAX);
+        const after = file.status === 'D' ? { bytes: null, tooLarge: false } : await fileAt(found.dir, found.commit, file.path, MAX);
+        // Git's own test for binary: a NUL byte in the first 8000.
+        const binary = [before.bytes, after.bytes].some((b) => !!b && b.subarray(0, 8000).includes(0));
+        const text = (b) => (b === null || binary ? null : b.toString('utf8').replace(/^\uFEFF/, ''));
+        return {
+            path: file.path,
+            ...(file.oldPath ? { oldPath: file.oldPath } : {}),
+            status: file.status,
+            before: text(before.bytes),
+            after: text(after.bytes),
+            binary,
+            tooLarge: before.tooLarge || after.tooLarge,
+        };
+    }
+    /** The repository and the two commits a task's changes lie between, or why there are none. */
+    async changesOf(sessionId, taskId, runId) {
+        await this.init();
+        const session = await this.store.getSession(sessionId);
+        const task = session?.tasks.find((t) => t.id === taskId);
+        if (!session || !task)
+            return { problem: 'No such task.' };
+        const chosen = runId ? resolveRunId(task, runId) : task.runId;
+        if (runId && !chosen)
+            return { problem: 'That attempt is not one of this task\'s.' };
+        const vcs = !chosen || chosen === task.runId ? task.vcs : (task.attempts ?? []).find((a) => a.runId === chosen)?.vcs;
+        if (!vcs?.baseCommit || !vcs.commit) {
+            return {
+                problem: vcs?.branch
+                    ? 'This attempt committed nothing, so there are no changes to show.'
+                    : 'Version control was not on for this attempt, so its changes were not recorded.',
+            };
+        }
+        const dir = repoDirOf(session);
+        if (!dir)
+            return { problem: 'The session has no repository folder set.' };
+        return { dir, base: vcs.baseCommit, commit: vcs.commit, branch: vcs.branch };
+    }
     async taskFiles(sessionId, taskId, runId) {
         const cfg = await this.settings.load();
         const s = await this.store.getSession(sessionId);
@@ -1947,6 +2024,8 @@ let OperatorService = class OperatorService {
                     readOnly: t.readOnly || undefined,
                     autoRetries: t.autoRetries || undefined,
                     attempt: t.attempt,
+                    changedFiles: t.vcs?.commit && t.vcs.baseCommit ? (t.vcs.files?.length ?? 0) : undefined,
+                    interrupted: t.status === 'aborted' && !!t.interruption ? true : undefined,
                     attempts: (t.attempts ?? []).map((a, n) => {
                         const from = a.startedAt ? Date.parse(a.startedAt) : undefined;
                         const to = a.finishedAt ? Date.parse(a.finishedAt) : undefined;
@@ -1961,6 +2040,7 @@ let OperatorService = class OperatorService {
                             reason: a.reason,
                             runId: a.runId,
                             branch: a.vcs?.branch,
+                            changedFiles: a.vcs?.commit && a.vcs.baseCommit ? (a.vcs.files?.length ?? 0) : undefined,
                         };
                     }),
                 });

package/dist/src/plan/brief.js

@@ -726,7 +726,7 @@ in those words, every time:
   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)"**
-     (it reads **"Continue: run {f} failed and {n} queued task(s) in {s} session(s)"** when a chain
+     (it reads **"Continue: run {f} unfinished and {n} queued task(s) in {s} session(s)"** when a chain
      has a failed task).
   4. In **"Before it continues"** every task is ticked. To run only the fixed one, press
      **"only this one"** beside it.
@@ -736,7 +736,7 @@ in those words, every time:
   A check that is wrong rather than a prompt that is wrong is edited instead: **"Edit"** on the
   task card, then **"What it checks"**, **"Must be"** and **"Command"** under **"Checks"**, then
   **"Save and queue it again"** — which, like every "queue" button, starts nothing by itself.
-  A task that ended **limit-reached** is carried on in its own chat instead: **"Continue in the
+  A task that ended **limit-reached**, or **aborted** because the bot stopped under it, is carried on in its own chat instead: **"Continue in the
   same chat"** on its card on the session page, then **"Run {n} task(s)"** at the top of that page.
   When a failure shows up while the run is still going, **"Pause after this task"** holds the rest
   while you work it out.
@@ -887,7 +887,7 @@ const PHASE3_BG = `
   1. В \`/history\`, в изгледа **„Поток“**, натисни **„Поправи prompt-а и върни в опашката“** на този ред.
   2. Замени текста с горния и натисни **„Запази и върни в опашката“**.
   3. Под **„Какво следва“** натисни **„Продължи: пусни {n} чакащи задачи в {s} сесии“** (пише
-     **„Продължи: пусни {f} провалили се и {n} чакащи задачи в {s} сесии“**, когато във верига има
+     **„Продължи: пусни {f} недовършени и {n} чакащи задачи в {s} сесии“**, когато във верига има
      провалена задача).
   4. В **„Преди да продължи“** всички задачи са отметнати. За да пуснеш само поправената, натисни
      **„само тази“** до нея.
@@ -897,7 +897,7 @@ const PHASE3_BG = `
   Когато е сгрешена проверката, а не prompt-ът, се редактира друго: **„Редактирай“** на картата
   на задачата, после **„Какво проверява“**, **„Трябва“** и **„Команда“** под **„Проверки“**, после
   **„Запази и върни в опашката“** — който, като всеки бутон за връщане в опашката, сам не пуска нищо.
-  Задача, завършила с **limit-reached**, продължава в собствения си чат: **„Продължи в същия чат“**
+  Задача, завършила с **limit-reached** или **aborted**, защото ботът е спрял под нея, продължава в собствения си чат: **„Продължи в същия чат“**
   на картата ѝ на страницата на сесията, после **„Пусни {n} задача(и)“** горе на същата страница.
   Когато провал се покаже, докато пускането още върви, **„Пауза след тази задача“** задържа
   останалото, докато го разбереш.

package/dist/src/plan/systemGuide.js

@@ -1442,8 +1442,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Continue in the same chat',
                         bg: 'Продължи в същия чат',
-                        doesEn: 'Only on a task stopped at its limit: queues it to carry on in the same chat and branch with a fresh count. Then press "Run {n} task(s)".',
-                        doesBg: 'Само на задача, спряла на лимита: нарежда я да продължи в същия чат и клон с нов брояч. После натиснете „Пусни {n} задача(и)“.',
+                        doesEn: 'On a task that stopped before it finished (its limit, the bot stopping, the operator): queues it to carry on in the same chat and branch. Then "Run {n} task(s)".',
+                        doesBg: 'На задача, спряла преди да приключи (лимит, спрял бот, оператор): нарежда я да продължи в същия чат и клон. После „Пусни {n} задача(и)“.',
                     },
                     {
                         key: 'task.rerun',
@@ -1549,6 +1549,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'The files the task\'s commit changed.',
                         doesBg: 'Файловете, които комитът на задачата е променил.',
                     },
+                    {
+                        key: 'diff.open',
+                        kind: 'button',
+                        en: 'See the changes ({n} file(s))',
+                        bg: 'Виж промените ({n} файла)',
+                        doesEn: 'Where the attempt committed: every file it changed, before on the left and after on the right, scrolling together. Also under each earlier attempt.',
+                        doesBg: 'Където опитът е комитнал: всеки променен файл, преди вляво и след вдясно, превъртани заедно. И под всеки по-ранен опит.',
+                    },
                     {
                         key: 'task.deviations',
                         kind: 'disclosure',
@@ -2102,6 +2110,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'Downloads what the runner did: the environment, every event and step with its exit code, the review machinery.',
                         doesBg: 'Изтегля какво е направил runner-ът: средата, всяко събитие и стъпка с кода на изход, механиката на рецензията.',
                     },
+                    {
+                        key: 'diff.open',
+                        kind: 'button',
+                        en: 'See the changes ({n} file(s))',
+                        bg: 'Виж промените ({n} файла)',
+                        doesEn: 'Where the attempt committed: every file it changed, before on the left and after on the right, scrolling together.',
+                        doesBg: 'Където опитът е комитнал: всеки променен файл, преди вляво и след вдясно, превъртани заедно.',
+                    },
                     {
                         key: 'story.show',
                         kind: 'button',
@@ -2300,6 +2316,14 @@ export const SYSTEM_GUIDE = [
                 en: 'What is next',
                 bg: 'Какво следва',
                 controls: [
+                    {
+                        key: 'reg.interruptedTitle',
+                        kind: 'note',
+                        en: 'The bot stopped in the middle of the work.',
+                        bg: 'Ботът спря посред работата.',
+                        doesEn: 'After the bot stopped under a run (power, Ctrl+C, a crash): the stopped tasks\' work is kept, and "Continue" carries them on where they stopped.',
+                        doesBg: 'След като ботът е спрял посред пускане (ток, Ctrl+C, срив): свършеното е запазено, а „Продължи“ продължава спрелите задачи оттам, където са спрели.',
+                    },
                     {
                         key: 'batch.pause',
                         kind: 'button',
@@ -2335,8 +2359,8 @@ export const SYSTEM_GUIDE = [
                     {
                         key: 'reg.continueWithFailed',
                         kind: 'button',
-                        en: 'Continue: run {f} failed and {n} queued task(s) in {s} session(s)',
-                        bg: 'Продължи: пусни {f} провалили се и {n} чакащи задачи в {s} сесии',
+                        en: 'Continue: run {f} unfinished and {n} queued task(s) in {s} session(s)',
+                        bg: 'Продължи: пусни {f} недовършени и {n} чакащи задачи в {s} сесии',
                         doesEn: 'The same button when a failed task of a chained session would go back into the queue with the queued ones.',
                         doesBg: 'Същият бутон, когато провалена задача от сесия-верига би се върнала в опашката заедно с чакащите.',
                     },
@@ -2401,8 +2425,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Continue without asking',
                         bg: 'Продължи без да пита',
-                        doesEn: 'Starts exactly the ticked tasks and runs every command without asking (asks "are you sure" first unless Settings say otherwise). Ticked failed tasks start afresh.',
-                        doesBg: 'Пуска точно отметнатите задачи и изпълнява всяка команда без питане (първо пита „сигурен ли си“, освен ако Настройките казват друго). Отметнатите провалени задачи тръгват отначало.',
+                        doesEn: 'Starts exactly the ticked tasks without asking (after "are you sure" unless Settings say otherwise). Stopped ones (aborted, limit reached) continue where they stopped; failed or blocked ones start afresh.',
+                        doesBg: 'Пуска точно отметнатите задачи без питане (след „сигурен ли си“, освен ако Настройките казват друго). Спрелите (прекратени, с лимит) продължават откъдето спряха; провалените и блокираните тръгват отначало.',
                     },
                     {
                         key: 'reg.continueGo',
@@ -2476,6 +2500,77 @@ export const SYSTEM_GUIDE = [
                     },
                 ],
             },
+            {
+                headingKey: 'diff.title',
+                en: 'Changes in "{title}"',
+                bg: 'Промени в „{title}“',
+                controls: [
+                    {
+                        key: 'diff.nextChange',
+                        kind: 'button',
+                        en: 'Next change',
+                        bg: 'Следваща промяна',
+                        doesEn: 'Jumps to the next edit (key n).',
+                        doesBg: 'Отива на следващата промяна (клавиш n).',
+                    },
+                    {
+                        key: 'diff.prevChange',
+                        kind: 'button',
+                        en: 'Previous change',
+                        bg: 'Предишна промяна',
+                        doesEn: 'The one before (key p).',
+                        doesBg: 'Предишната (клавиш p).',
+                    },
+                    {
+                        key: 'diff.nextFile',
+                        kind: 'button',
+                        en: 'Next file',
+                        bg: 'Следващ файл',
+                        doesEn: 'The next file in the list on the left (key ]).',
+                        doesBg: 'Следващият файл от списъка вляво (клавиш ]).',
+                    },
+                    {
+                        key: 'diff.prevFile',
+                        kind: 'button',
+                        en: 'Previous file',
+                        bg: 'Предишен файл',
+                        doesEn: 'The file before (key [).',
+                        doesBg: 'Предишният файл (клавиш [).',
+                    },
+                    {
+                        key: 'diff.gap',
+                        kind: 'button',
+                        en: '⋯ {n} unchanged line(s) — show them',
+                        bg: '⋯ {n} непроменени реда — покажи ги',
+                        doesEn: 'Opens a folded stretch of unchanged lines.',
+                        doesBg: 'Отваря сгънат участък непроменени редове.',
+                    },
+                    {
+                        key: 'diff.whole',
+                        kind: 'checkbox',
+                        en: 'Show the whole file',
+                        bg: 'Покажи целия файл',
+                        doesEn: 'Every line, nothing folded.',
+                        doesBg: 'Всички редове, нищо сгънато.',
+                    },
+                    {
+                        key: 'diff.wrap',
+                        kind: 'checkbox',
+                        en: 'Wrap long lines',
+                        bg: 'Пренасяй дългите редове',
+                        doesEn: 'Off: long lines stay on one line and the table scrolls sideways.',
+                        doesBg: 'Изключено: дългите редове остават на един ред и таблицата се превърта настрани.',
+                    },
+                    {
+                        key: 'diff.close',
+                        kind: 'button',
+                        en: 'Close',
+                        bg: 'Затвори',
+                        doesEn: 'Closes the view (Esc).',
+                        doesBg: 'Затваря изгледа (Esc).',
+                    },
+                ],
+            },
         ],
     },
     {
@@ -2702,6 +2797,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'How many minutes one task may run (default 240) before it stops as limit reached; saved as you type.',
                         doesBg: 'Колко минути може да върви една задача (по подразбиране 240), преди да спре като достигнат лимит; запазва се, докато пишете.',
                     },
+                    {
+                        key: 'exec.replyTimeout',
+                        kind: 'field',
+                        en: 'How long to wait for a reply from the chat',
+                        bg: 'Колко да се чака отговор от чата',
+                        doesEn: 'Seconds to wait for a chat reply (default 900); a reply not finished by then fails the task with "Copilot did not finish a reply within …".',
+                        doesBg: 'Секунди чакане на отговор от чата (по подразбиране 900); незавършен дотогава отговор проваля задачата с „Copilot did not finish a reply within …“.',
+                    },
                     {
                         key: 'exec.retryBlocked',
                         kind: 'field',
@@ -3123,10 +3226,10 @@ const KIND_WORDS = {
     tab: { en: 'tab', bg: 'раздел' },
     badge: { en: 'badge', bg: 'етикет' },
     disclosure: { en: 'fold', bg: 'разгъване' },
-    note: { en: 'line on screen', bg: 'ред на екрана' },
+    note: { en: 'text', bg: 'текст' },
 };
-const INTRO_EN = 'Every label in quotes below is the exact text on the screen. Name the control by that text — press "Check it" — instead of describing it, and give the route so the operator knows which page they are on. A label with {braces} in it is filled in with numbers or names at the time.';
-const INTRO_BG = 'Всеки надпис в кавички по-долу е точният текст на екрана. Назовавай контрола с този текст — натисни „Провери“ — вместо да го описваш, и казвай маршрута, за да знае операторът на коя страница е. Надпис с {скоби} се попълва с числа или имена в момента.';
+const INTRO_EN = 'Every label in quotes below is the exact text on the screen. Name the control by that text — press "Check it" — instead of describing it, and give the route so the operator knows which page they are on. A label with {braces} in it is filled in with numbers or names at the time. A label with no kind after it is a button.';
+const INTRO_BG = 'Всеки надпис в кавички по-долу е точният текст на екрана. Назовавай контрола с този текст — натисни „Провери“ — вместо да го описваш, и казвай маршрута, за да знае операторът на коя страница е. Надпис с {скоби} се попълва с числа или имена в момента. Надпис без вид след него е бутон.';
 /**
  * The guide as the Markdown section the brief embeds. Dense on purpose: the brief is pasted
  * into a chat window by hand and read by a model, so the words and what they do earn their
@@ -3146,8 +3249,10 @@ export function systemGuideSection(lang) {
             lines.push('');
             lines.push(`**${bg ? section.bg : section.en}**`);
             for (const control of section.controls) {
-                const word = KIND_WORDS[control.kind][lang];
-                lines.push(`- "${bg ? control.bg : control.en}" (${word}) — ${bg ? control.doesBg : control.doesEn}`);
+                // A button is the common case and is said once in the introduction instead of on 120 lines:
+                // the brief is pasted into a chat whose composer has a limit, and this is where it goes.
+                const kind = control.kind === 'button' ? '' : ` (${KIND_WORDS[control.kind][lang]})`;
+                lines.push(`- "${bg ? control.bg : control.en}"${kind} — ${bg ? control.doesBg : control.doesEn}`);
             }
         }
     }

package/dist/src/session/compose.js

@@ -1,17 +1,4 @@
-/**
- * Builds the messages that open a task in the chat.
- *
- * Two shapes, because a conversation is opened once and then reused:
- *
- *   first task in a session   level 1 (the contract, sent on its own and acknowledged),
- *                             then level 2 plus the task in one message
- *   later tasks               a short reminder that the contract still applies,
- *                             then level 2 plus the task
- *
- * Level 2 is always sent with the task, even when it did not change, because it is cheap
- * and it keeps each task self-contained in the transcript. The priority of level 1 over
- * level 2 is stated inside level 1 itself; the composition only makes the boundary visible.
- */
+import { describeInterruption } from './interruption.js';
 const LEVEL2_HEADER = '## Project instructions (level 2)';
 const TASK_HEADER = '## Task';
 /**
@@ -50,6 +37,25 @@ function level2Block(level2) {
  * The messages to send, in order. The last one is the one whose reply starts the loop.
  * `firstMessage` is what the UI shows as "the prompt that opened this task".
  */
+/**
+ * Why the attempt being continued stopped, and where it was, in the words the chat is sent. The
+ * chat was mid-conversation when it stopped, so what it most needs is to know that nothing it did
+ * failed, that the files are as its work left them, and — after the bot stopped under it — which of
+ * the steps it had just asked for actually ran.
+ */
+function whyItStopped(c) {
+    if (c.how === 'interrupted') {
+        const where = c.interruption ? `\n\n${describeInterruption(c.interruption)}\n\n` : ' ';
+        return ('The runner stopped unexpectedly while this task was in progress — the program was closed, the machine went off or it ' +
+            'crashed; nothing you did failed — and it has now started again. The files are as your work left them, and what had ' +
+            `changed is committed on this branch.${where}`.trimEnd());
+    }
+    if (c.how === 'stopped') {
+        return 'It was stopped by the operator before it finished — not because anything failed. The files are as you left them.';
+    }
+    const why = c.stoppedBecause ? ` (${c.stoppedBecause})` : '';
+    return `It stopped because the runner's limit was reached${why} — not because anything failed. The files are as you left them.`;
+}
 export function composeOpening(input) {
     const taskBlock = `${TASK_HEADER} ${input.taskNumber}: ${input.taskTitle.trim() || 'untitled'}\n\n${input.prompt.trim()}`;
     /*
@@ -58,18 +64,17 @@ export function composeOpening(input) {
      * conversation was lost does the task go out in full, with a line saying it is a continuation.
      */
     if (input.continuing && input.contractAlreadySent) {
-        const why = input.continuing.stoppedBecause ? ` (${input.continuing.stoppedBecause})` : '';
         const message = `Continue task ${input.taskNumber}: ${input.taskTitle.trim() || 'untitled'}, in this same conversation. ` +
-            `It stopped because the runner's limit was reached${why} — not because anything failed. ` +
-            `The files are as you left them. Do not start over and do not repeat work that is done: start from ` +
+            `${whyItStopped(input.continuing)} ` +
+            `Do not start over and do not repeat work that is done: start from ` +
             `your plan, say in \`notes\` which stages are done and which one you are on, and carry on. ` +
             `The assignment is the one you were given above; it has not changed. Step numbering restarts at 1.\n\n` +
             `${runnerBlock(input)}`.trimEnd();
         return { messages: [message], firstMessage: message };
     }
     const continuationLine = input.continuing
-        ? `\n\nThis continues an earlier attempt at this task that stopped at the runner's limit. The files are as ` +
-            `that attempt left them: look at what is already done before changing anything, and carry on from there.`
+        ? `\n\nThis continues an earlier attempt at this task. ${whyItStopped(input.continuing)} ` +
+            `Look at what is already done before changing anything, and carry on from there.`
         : input.buildsOn
             ? `\n\nThis task was done once already (attempt ${input.buildsOn.fromAttempt}), and that work is in your ` +
                 `working tree. The text above is a new instruction for it: look at what is there first, build on it, and ` +

package/dist/src/session/interruption.js

@@ -0,0 +1,104 @@
+/**
+ * Where an attempt was when the bot stopped under it — the power went, the machine shut down,
+ * `npm start` was stopped with Ctrl+C, the process crashed — read back from what it had written.
+ *
+ * Nothing in memory survives that, but the run folder does, and it was written as the work went:
+ * the transcript has every reply and every step as it was proposed, started and finished, and each
+ * step's output is in its own log under `steps/`. So the last reply the chat sent, which of the
+ * steps it asked for had finished (and how), which one was cut off while it ran, which never ran,
+ * and whether their results had already gone back to the chat — all of that is on disk. It is what
+ * the chat needs to be told to carry on rather than start over, and what the operator needs to see
+ * to trust that it can.
+ */
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parseStepLog } from './story.js';
+const TAIL_CHARS = 1200;
+/** Reads an attempt's run folder; null when there is no transcript to read. */
+export async function readInterruption(runDir) {
+    const raw = await readFile(join(runDir, 'transcript.jsonl'), 'utf8').catch(() => null);
+    if (raw === null)
+        return null;
+    const events = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            events.push(JSON.parse(line));
+        }
+        catch {
+            // A line cut in half by the stop itself: the rest is still good.
+        }
+    }
+    const lastActivity = events.at(-1)?.at;
+    let replyAt = -1;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        if (events[i].type === 'reply-parsed') {
+            replyAt = i;
+            break;
+        }
+    }
+    if (replyAt < 0)
+        return { lastActivity, iteration: 0, steps: [], resultsSent: false };
+    const reply = events[replyAt];
+    const iteration = Number(reply.iteration) || 0;
+    const after = events.slice(replyAt + 1);
+    const count = Number(reply.steps) || 0;
+    const steps = [];
+    for (let id = 1; id <= count; id += 1) {
+        const finished = after.find((e) => e.type === 'step-finished' && e.id === id);
+        const skipped = after.find((e) => e.type === 'step-skipped' && e.id === id);
+        const started = after.some((e) => e.type === 'step-started' && e.id === id);
+        const proposed = after.find((e) => e.type === 'step-proposed' && e.id === id);
+        const state = finished ? 'finished' : skipped ? 'skipped' : started ? 'cut' : 'not-run';
+        const step = { id, state };
+        if (typeof proposed?.description === 'string')
+            step.command = proposed.description;
+        if (finished) {
+            step.outcome = String(finished.outcome ?? '');
+            if (typeof finished.exitCode === 'number')
+                step.exitCode = finished.exitCode;
+        }
+        if (state === 'finished' || state === 'cut') {
+            const log = await readFile(join(runDir, 'steps', `${iteration}-${id}.log`), 'utf8').catch(() => '');
+            const output = parseStepLog(log).output;
+            if (output)
+                step.outputTail = output.length > TAIL_CHARS ? `…${output.slice(-TAIL_CHARS)}` : output;
+        }
+        steps.push(step);
+    }
+    // Sent back only when the results were written *and* a message went out after them.
+    const reportAt = after.findIndex((e) => e.type === 'report-written' && Number(e.iteration) === iteration);
+    const resultsSent = reportAt >= 0 && after.slice(reportAt + 1).some((e) => e.type === 'message-sent');
+    return { lastActivity, iteration, replyStatus: typeof reply.status === 'string' ? reply.status : undefined, steps, resultsSent };
+}
+/**
+ * What the chat is told about it, in the continuation message: which steps ran, with the end of
+ * their output, which was cut off, which never ran — or that the results were already sent.
+ */
+export function describeInterruption(i) {
+    if (i.iteration === 0)
+        return 'It stopped before your first reply arrived, so nothing of this task had been run yet.';
+    if (i.resultsSent) {
+        return `The results of the steps from your last reply were already sent to you (above), and your answer to them was not received. Carry on from those results.`;
+    }
+    if (i.replyStatus === 'done' && i.steps.length === 0) {
+        return 'Your last reply reported the task done; the runner was checking it when it stopped. If nothing is left, reply again with your summary.';
+    }
+    if (i.steps.length === 0)
+        return 'Your last reply asked for no steps.';
+    const lines = [`Of the ${i.steps.length} step(s) in your last reply:`];
+    for (const s of i.steps) {
+        const what = s.state === 'finished'
+            ? `ran to the end (exit ${s.exitCode ?? '?'})`
+            : s.state === 'cut'
+                ? 'was running when the runner stopped — it may have done only part of its work; check its effect before relying on it'
+                : s.state === 'skipped'
+                    ? 'was not run (refused or skipped)'
+                    : 'did not run';
+        lines.push(`- step ${s.id} ${what}.`);
+        if (s.outputTail)
+            lines.push('  Its output ended with:', '  ```', ...s.outputTail.split('\n').map((l) => `  ${l}`), '  ```');
+    }
+    return lines.join('\n');
+}