copilot-operator 0.1.23 → 0.1.25

package/dist/src/plan/schema.js

@@ -574,7 +574,7 @@ function readPlan(text) {
     return {
         ok: true,
         plan: parsed.data,
-        warnings: [...warnings, ...duplicateNameWarnings(parsed.data), ...indexCheckWarnings(parsed.data)],
+        warnings: [...warnings, ...duplicateNameWarnings(parsed.data), ...indexCheckWarnings(parsed.data), ...commitsOffWarnings(parsed.data)],
         summary: summarise(parsed.data),
     };
 }
@@ -588,6 +588,16 @@ function readPlan(text) {
  * that was meant; the negative form (`output-omits` on `ls-files`, "node_modules is not
  * tracked") is fine and stays silent.
  */
+/**
+ * A branch per task with commits off isolates only the first task: nothing is committed, so the next
+ * task finds the first one's files in the tree and runs on top of them without a branch of its own
+ * (live run 2026-10-03). Said at import, where it can still be changed.
+ */
+function commitsOffWarnings(plan) {
+    return plan.sessions.flatMap((s, i) => s.vcs?.enabled !== false && s.vcs?.commitOnFinish === false && (s.vcs?.branchMode ?? 'per-task') === 'per-task' && s.tasks.length > 1
+        ? [`sessions[${i}] ("${s.name}"): a branch per task with commits off gives only the first task a branch of its own — the others run on top of its uncommitted files. Use "per-session", or let the runner commit.`]
+        : []);
+}
 function indexCheckWarnings(plan) {
     const out = [];
     plan.sessions.forEach((s, i) => {

package/dist/src/plan/systemGuide.js

@@ -717,6 +717,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'The branch the plan asked the sessions to start from, and its tip.',
                         doesBg: 'Клонът, от който планът иска сесиите да тръгнат, и върхът му.',
                     },
+                    {
+                        key: 'runvcs.workBranch',
+                        kind: 'note',
+                        en: 'Branch the run works on',
+                        bg: 'Клон, на който ще се работи',
+                        doesEn: 'Shown when it is not the branch the repository is on: the session’s own branch (after a Restore, the restore branch) or the existing branch it carries on, and its tip.',
+                        doesBg: 'Показва се, когато не е клонът, на който е хранилището: собственият клон на сесията (след Restore — клонът от възстановяването) или съществуващият клон, който продължава, и върхът му.',
+                    },
                     {
                         key: 'runvcs.sessions',
                         kind: 'note',
@@ -746,8 +754,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Create starting snapshot on {branch}',
                         bg: 'Създай начална снимка върху {branch}',
-                        doesEn: 'Commits the approved input files on top of the base branch, on a new cop/baseline/ branch, without switching branches or touching the checkout; every session of the run starting from that branch starts from it, chained ones carry it on. Recommended when the plan names that branch. Not offered while other files are uncommitted.',
-                        doesBg: 'Комитва одобрените входни файлове върху базовия клон, на нов клон cop/baseline/, без да сменя клона и без да пипа работното копие; всяка сесия от пускането, тръгваща от този клон, тръгва от снимката, а свързаните във верига я продължават. Препоръчано, когато планът посочва този клон. Не се предлага, докато има други некомитнати файлове.',
+                        doesEn: 'Commits the approved input files on top of the base branch, on a new cop/baseline/ branch, without switching branches; when the session updates from the remote, the base branch is first fast-forwarded to it, which moves the checkout too if that branch is checked out. Every session of the run starting from that branch starts from it, chained ones carry it on. Recommended when the plan names that branch. Not offered while other files are uncommitted.',
+                        doesBg: 'Комитва одобрените входни файлове върху базовия клон, на нов клон cop/baseline/, без да сменя клона; когато сесията се обновява от remote, базовият клон първо се придвижва напред до него, което мести и работното копие, ако този клон е изтеглен. Всяка сесия от пускането, тръгваща от този клон, тръгва от снимката, а свързаните във верига я продължават. Препоръчано, когато планът посочва този клон. Не се предлага, докато има други некомитнати файлове.',
                     },
                     {
                         key: 'runvcs.snapshotHere',
@@ -762,8 +770,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Use the current branch instead of {branch}',
                         bg: 'Използвай текущия branch вместо {branch}',
-                        doesEn: 'The sessions start from the branch the repository is on instead of the base branch: their "Start from" becomes "From wherever the repository is". Nothing is committed.',
-                        doesBg: 'Сесиите тръгват от клона, на който е хранилището, вместо от базовия: „Откъде тръгва“ им става „Откъдето е хранилището“. Нищо не се комитва.',
+                        doesEn: 'The sessions start from the branch the repository is on instead of the base branch: that branch becomes their base branch, so each starts from it even after HEAD has moved. Nothing is committed.',
+                        doesBg: 'Сесиите тръгват от клона, на който е хранилището, вместо от базовия: той им става базов клон, така че всяка тръгва от него, дори HEAD да се е преместил. Нищо не се комитва.',
                     },
                     {
                         key: 'runvcs.allowSnapshot',

package/dist/src/protocol/parser.js

@@ -54,6 +54,32 @@ function findJsonCandidates(markdown) {
     }
     return out;
 }
+/**
+ * The stop word taken out of a text wherever it stands as a word of its own, and the spacing tidied
+ * only where it stood: a text without it comes back untouched, and a command such as "Get-Content .\src"
+ * keeps its space (live run 2026-10-04).
+ */
+export function withoutMarker(text, marker) {
+    if (text === undefined || !marker)
+        return text;
+    const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const edge = String.raw `\s.,;:!?"'«»„“”()\[\]-`;
+    const word = new RegExp(`(^|[${edge}])${escaped}(?=$|[${edge}])`, 'gu');
+    if (!word.test(text))
+        return text;
+    word.lastIndex = 0;
+    const HOLE = '\u0000';
+    const out = text
+        .replace(word, `$1${HOLE}`)
+        .replace(/\([ \t]*\u0000[ \t]*\)|\[[ \t]*\u0000[ \t]*\]/g, HOLE)
+        .replace(/([.!?])[ \t]*\u0000[ \t]*\.+(?=\s|$)/g, '$1')
+        .replace(/[ \t]*\u0000[ \t]*([.,;:!?])(?=\s|$)/g, '$1')
+        .replace(/[ \t]+\u0000[ \t]+/g, ' ')
+        .replace(/\u0000/g, '')
+        .trim();
+    // Nothing but the stop word: kept as it was rather than leaving a done reply with no summary.
+    return out === '' ? text : out;
+}
 /** Removes Copilot's 【n-hash】 citation markers and the whitespace they leave behind. */
 export function stripCitations(text) {
     if (text === undefined)
@@ -164,15 +190,17 @@ export function parseReply(markdown, opts) {
                 continue;
             }
             const reply = result.data;
-            // Copilot appends citation markers such as 【1-8313d0】 to prose it grounded in a file.
-            // They mean nothing outside the chat and would otherwise end up in the UI and the log.
-            reply.notes = stripCitations(reply.notes);
-            reply.summary = stripCitations(reply.summary);
-            const steps = reply.steps.map((s) => ({ ...s, shell: s.shell ?? opts.defaultShell }));
             // A blank stop word is no stop word. The setting is free text, and every reply contains the
             // empty string and nearly every one a space, so searching for either would read each
             // `continue` that carries a summary as done and close the task after one round.
             const marker = opts.stopMarker.trim();
+            // Copilot appends citation markers such as 【1-8313d0】 to prose it grounded in a file.
+            // They mean nothing outside the chat and would otherwise end up in the UI and the log.
+            // The stop word too, which the contract asks for "somewhere in the reply": it is a signal to the
+            // runner, and written into the summary it ended up in commit messages and exports (live run 2026-10-03).
+            reply.notes = withoutMarker(stripCitations(reply.notes), marker);
+            reply.summary = withoutMarker(stripCitations(reply.summary), marker);
+            const steps = reply.steps.map((s) => ({ ...s, shell: s.shell ?? opts.defaultShell }));
             const markerHit = marker !== '' && markdown.includes(marker);
             const hasSummary = (reply.summary ?? '').trim().length > 0;
             // The stop word alone is not enough to end a task any more: the summary is the

package/dist/src/protocol/reporter.js

@@ -25,6 +25,8 @@ function outcomeSummary(r) {
             // not here — and it never reached a process, so it has no exit code to report. Said as a
             // refusal, apart from a step that ran and exited non-zero: the move after one is to write
             // the step differently, after the other it is to read the output and fix the work.
+            if (r.skippedAfter !== undefined)
+                return `step ${r.id} was not run, because step ${r.skippedAfter} was refused; send it again after that one is replaced`;
             return `step ${r.id} was refused by the runner and never ran (no exit code); the reason is under it`;
         case 'aborted':
             // A person stopped or skipped it — a reason to carry on without it, not to rewrite it.

package/dist/src/session/compose.js

@@ -18,14 +18,22 @@ function runnerBlock(input) {
  * What a read-only task is told. The rule is enforced by the runner from the working tree,
  * so the note is a warning about a fact, not a request.
  */
-export const READ_ONLY_NOTE = [
-    '## Read-only task',
-    '',
-    'This task must not change any file: it reads, runs and reports. The runner fails it if the',
-    'working tree has changed when it ends, whatever the summary says, and commits the change on',
-    "the task's branch so it is not lost. If a review finding asks you to change something, that",
-    'is a finding about the task, not about the work: dispute it rather than comply.',
-].join('\n');
+export function readOnlyNote(commits, artifacts = []) {
+    return [
+        '## Read-only task',
+        '',
+        'This task must not change any file: it reads, runs and reports. The runner fails it if it',
+        'changed the working tree, whatever the summary says' +
+            (commits ? ", and commits the change on the task's branch so it is not lost." : '. Nothing is committed in this session, so a change would stay in the working tree.'),
+        'Helper scripts may go in `.cop-tmp`, which is not part of the project.' +
+            (artifacts.length > 0 ? ` A report or other evidence goes under ${artifacts.join(', ')}: kept with the run, never committed, and the one place this task may write.` : ''),
+        "This rule wins over any instruction above — the project's or the persona's — to change code. If a review",
+        'finding asks you to change something, that is a finding about the task, not about the work: dispute it',
+        'rather than comply.',
+    ].join('\n');
+}
+/** The note for a session that commits: see `readOnlyNote`. */
+export const READ_ONLY_NOTE = readOnlyNote(true);
 function level2Block(level2) {
     const body = level2.trim();
     return body.length > 0
@@ -51,7 +59,8 @@ function whyItStopped(c) {
             `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 where = c.interruption ? `\n\n${describeInterruption(c.interruption).replace(/when the runner stopped/g, 'when it was stopped')}\n\n` : ' ';
+        return `It was stopped by the operator before it finished — not because anything failed. The files are as you left them.${where}`.trimEnd();
     }
     const why = c.stoppedBecause ? ` (${c.stoppedBecause})` : '';
     // Out of rounds of fixing: something did say no, and the chat needs to hear it was not waved through.

package/dist/src/session/exportRecord.js

@@ -78,10 +78,11 @@ async function conversationOf(task, runsDir) {
  * list the runner read back from the repository after committing, so the count is what is
  * actually on that branch since it was cut, not what anybody assumed.
  */
-function versionControlLines(task, session) {
+export function versionControlLines(task, session) {
     const vcs = task.vcs;
+    const loose = task.treeChanged?.length ? [`changed, not committed: ${task.treeChanged.length} file(s) — ${task.treeChanged.slice(0, 10).join(', ')}${task.treeChanged.length > 10 ? ', …' : ''}`] : [];
     if (!session.vcs?.enabled)
-        return ['version control : off for this session'];
+        return ['version control : off for this session', ...loose];
     if (!vcs || (!vcs.branch && !vcs.problem))
         return ['version control : nothing was recorded for this task'];
     if (!vcs.branch)
@@ -94,7 +95,13 @@ function versionControlLines(task, session) {
         `branch     : ${vcs.branch}`,
         `started at : ${vcs.baseCommit ? vcs.baseCommit.slice(0, 8) : '—'} (the commit this task branched from)`,
         ...(before ? [`before commit: ${before.changed.length} path(s) changed or new in the working tree${before.changed.length ? ` — ${before.changed.slice(0, 10).join(', ')}` : ''}`] : []),
-        `commit     : ${vcs.commit ? vcs.commit.slice(0, 8) : vcs.problem ? 'none — see the note below' : 'none — the task changed no files'}`,
+        `commit     : ${vcs.commit
+            ? vcs.commit.slice(0, 8)
+            : vcs.problem
+                ? 'none — see the note below'
+                : session.vcs?.commitOnFinish === false
+                    ? `none — commits are off for this session${after && !after.clean ? ', so the changes stay in the working tree' : ''}`
+                    : 'none — the task changed no files'}`,
         ...(after
             ? [`after commit: on ${after.branch ?? '?'} at ${after.head ? after.head.slice(0, 8) : '?'}, ${after.clean ? 'working tree clean' : `still uncommitted: ${after.changed.slice(0, 10).join(', ')}`}`]
             : []),
@@ -102,6 +109,8 @@ function versionControlLines(task, session) {
     ];
     for (const line of commits)
         lines.push(`             ${line}`);
+    if (!vcs.commit)
+        lines.push(...loose);
     const files = vcs.files ?? [];
     if (files.length > 0) {
         lines.push(`files      : ${files.length} changed by this task's commit`);

package/dist/src/session/exports.js

@@ -21,7 +21,7 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { browserAfterPreflight, readRunLog } from './runLog.js';
+import { browserAfterPreflight, readRunLog, readSessionLog, refusedRunsOf } from './runLog.js';
 import { TASK_FIELD_ON_RERUN } from './store.js';
 import { botVersion } from '../config/version.js';
 import { withoutPersona } from '../plan/importPlan.js';
@@ -446,7 +446,7 @@ async function domainTask(session, task, runsDir) {
         iteration: e.iteration,
         status: e.status,
         notes: typeof e.notes === 'string' ? clip(e.notes, 1000) : undefined,
-        steps: steps.filter((s) => s.iteration === e.iteration).map((s) => ({ id: s.id, ran: s.description, outcome: s.refused ? `refused: ${s.refused}` : s.outcome, exitCode: s.exitCode })),
+        steps: steps.filter((s) => s.iteration === e.iteration).map((s) => ({ id: s.id, ran: s.description, outcome: s.refused ? (/^refused\b/i.test(s.refused) ? s.refused : `refused: ${s.refused}`) : s.outcome, exitCode: s.exitCode })),
     }));
     const p = splitPrompt(task.prompt);
     const failed = task.status !== 'done' && task.status !== 'queued' && task.status !== 'running' && task.status !== 'waiting-approval';
@@ -493,6 +493,10 @@ async function domainTask(session, task, runsDir) {
                         kind: session.vcsStart.kind,
                         commit: session.vcsStart.commit,
                         branch: session.vcsStart.branch,
+                        // What bringing the branch up to its remote did, why it started where it did, whose work it carries on.
+                        ...(session.vcsStart.update ? { update: session.vcsStart.update } : {}),
+                        ...(session.vcsStart.note ? { note: session.vcsStart.note } : {}),
+                        ...(session.vcsStart.fromSession ? { fromSession: session.vcsStart.fromSession } : {}),
                         ...(session.vcsStart.snapshot ? { snapshot: session.vcsStart.snapshot } : {}),
                         ...(session.vcsStart.inputs ? { inputs: session.vcsStart.inputs } : {}),
                     },
@@ -574,7 +578,7 @@ async function domainTask(session, task, runsDir) {
                 iteration: e.iteration,
                 status: e.status,
                 notes: typeof e.notes === 'string' ? clip(e.notes, 1000) : undefined,
-                steps: aSteps.filter((s) => s.iteration === e.iteration).map((s) => ({ id: s.id, ran: s.description, outcome: s.refused ? `refused: ${s.refused}` : s.outcome, exitCode: s.exitCode })),
+                steps: aSteps.filter((s) => s.iteration === e.iteration).map((s) => ({ id: s.id, ran: s.description, outcome: s.refused ? (/^refused\b/i.test(s.refused) ? s.refused : `refused: ${s.refused}`) : s.outcome, exitCode: s.exitCode })),
             }));
             const aFailed = a.status !== 'done';
             earlier.push({
@@ -586,7 +590,15 @@ async function domainTask(session, task, runsDir) {
                 iterations: a.iterations,
                 startedAt: a.startedAt,
                 finishedAt: a.finishedAt,
-                prompt: a.prompt !== task.prompt ? splitPrompt(a.prompt).prompt : undefined,
+                // The whole text it ran with, when it differs: a correction added under the expected result was cut off.
+                prompt: a.prompt !== task.prompt ? a.prompt : undefined,
+                ...(a.stopCode ? { stopCode: a.stopCode } : {}),
+                ...(a.freshRetry ? { freshRetry: true } : {}),
+                ...(a.vcs?.commit ? { commit: a.vcs.commit } : {}),
+                ...(JSON.stringify(a.scope ?? []) !== JSON.stringify(task.scope ?? []) ? { scope: a.scope ?? [] } : {}),
+                ...((a.readOnly ?? false) !== (task.readOnly ?? false) ? { readOnly: a.readOnly ?? false } : {}),
+                ...(a.checks && JSON.stringify(a.checks) !== JSON.stringify(task.checks ?? []) ? { checks: a.checks } : {}),
+                run: a.runGroup ? { id: a.runGroup.id, name: a.runGroup.name } : undefined,
                 whatTheChatTried: aRounds,
                 whatWasActuallyDone: { repository: a.vcs, deviations: a.deviations, disputes: a.disputes },
                 whyItFailed: aFailed
@@ -653,7 +665,8 @@ async function botTask(session, task, runsDir) {
     const byType = new Map();
     for (const e of events)
         byType.set(String(e.type), (byType.get(String(e.type)) ?? 0) + 1);
-    const problems = events.filter((e) => e.level === 'error' || e.level === 'warn').map(trimmed);
+    // A step waiting for the operator's answer is routine in a step-by-step run, not a problem (live run 2026-10-04).
+    const problems = events.filter((e) => (e.level === 'error' || e.level === 'warn') && e.type !== 'approval-requested').map(trimmed);
     const reviewEvents = events.filter((e) => String(e.type).startsWith('review-') || String(e.type).startsWith('finding-'));
     return {
         session: { id: session.id, name: session.name, model: session.model, modelInUse: session.modelInUse, reviewModel: session.review?.model },
@@ -694,6 +707,10 @@ async function botTask(session, task, runsDir) {
                 attempt: i + 1,
                 runId: a.runId,
                 runFolder: a.runId ? join(runsDir, a.runId) : undefined,
+                run: a.runGroup ? { id: a.runGroup.id, name: a.runGroup.name } : undefined,
+                policy: await policyOf(session, a, runsDir),
+                ...(a.stopCode ? { stopCode: a.stopCode } : {}),
+                ...(a.freshRetry ? { freshRetry: true } : {}),
                 status: a.status,
                 steps: stepsOf(aEvents).map((s) => ({ iteration: s.iteration, id: s.id, command: s.description, outcome: s.outcome, exitCode: s.exitCode, durationMs: s.durationMs, refused: s.refused })),
                 problems: aEvents.filter((e) => e.level === 'error' || e.level === 'warn').map(trimmed),
@@ -714,13 +731,32 @@ export async function buildBotExport(scope, runsDir, machine) {
      * What each run did before its tasks: the version control preflight and the moment the browser was
      * asked for, in the order they happened (`session/runLog.ts`), with the order checked rather than claimed.
      */
+    /*
+     * Every run the exported tasks took part in — the current attempt's and every earlier attempt's — and
+     * the runs of their sessions that were refused before a task began. Only the current attempt's run was
+     * listed, so a re-run made the first run's record disappear from the export (live run 2026-10-03).
+     */
     const runs = {};
-    for (const { task } of pairs) {
-        const id = task.runGroup?.id;
+    const add = async (id, name) => {
         if (!id || id in runs)
-            continue;
+            return;
         const preflight = await readRunLog(runsDir, id);
-        runs[id] = { name: task.runGroup?.name, preflight, order: browserAfterPreflight(preflight) };
+        const refused = preflight.some((e) => e.type === 'run-preflight-refused') && !preflight.some((e) => e.type === 'browser-launch-requested');
+        // Sessions refused at their turn in a run that went ahead (see `refusedRunsOf`).
+        const atTurn = preflight.filter((e) => e.type === 'run-preflight-refused' && e.data?.atTurn).flatMap((e) => (Array.isArray(e.data?.sessions) ? e.data.sessions : []));
+        runs[id] = { name, ...(refused ? { refused: true } : {}), ...(atTurn.length > 0 ? { refusedAtTurn: atTurn } : {}), preflight, order: browserAfterPreflight(preflight) };
+    };
+    /** What the operator did to each session's repository or start outside a run: see `appendSessionLog`. */
+    const operatorActions = {};
+    for (const { session, task } of pairs) {
+        if (!(session.id in operatorActions))
+            operatorActions[session.id] = await readSessionLog(runsDir, session.id);
+        await add(task.runGroup?.id, task.runGroup?.name);
+        for (const a of task.attempts ?? [])
+            await add(a.runGroup?.id, a.runGroup?.name);
+        await add(session.runGroup?.id, session.runGroup?.name);
+        for (const id of await refusedRunsOf(runsDir, session.id))
+            await add(id);
     }
     return {
         exportedAt: new Date().toISOString(),
@@ -729,6 +765,7 @@ export async function buildBotExport(scope, runsDir, machine) {
         about: `copilot-operator, the runner: ${scope.label}. The environment, every transcript event, every step with its exit code, the transport's retries, what was reaped, what the review machinery did. Read the domain export for what the task was about.`,
         machine,
         runs,
+        operatorActions,
         tasks,
     };
 }

package/dist/src/session/handoff.js

@@ -22,7 +22,7 @@ export function composeHandoff(task, notRun = []) {
             .map((c) => `committed with a finding left in place: ${c.name}`),
         ...(vcs.suspicious ?? []).map((s) => `committed although it looks like ${s.reason}: ${s.path}`),
         ...(vcs.foreignCommits ?? []).map((c) => `a commit on the branch the runner did not make: ${c}`),
-        ...(task.scopeReverted?.length ? [`put back because outside the task's scope: ${task.scopeReverted.join(', ')}`] : []),
+        ...(task.scopeReverted?.length ? [`put back because ${task.readOnly ? 'the task is read-only' : "outside the task's scope"}: ${task.scopeReverted.join(', ')}`] : []),
         ...(task.deviations ?? []).map((d) => `did not follow "${d.instruction}" as written: ${d.did}`),
     ];
     const manual = [];
@@ -34,7 +34,8 @@ export function composeHandoff(task, notRun = []) {
         manual.push('continue it in the same chat from the register, or run it again');
     if (task.status === 'blocked')
         manual.push(`unblock it: ${task.reason ?? 'see the reason'}`);
-    if (task.status === 'failed')
+    // A refusal of version control's own is fixed there, not in the prompt (live run 2026-10-03).
+    if (task.status === 'failed' && !vcs.problem)
         manual.push('read why it failed, fix the prompt or the checks, and queue it again');
     if (openFindings.length > 0)
         manual.push(`${openFindings.length} review finding(s) are open`);
@@ -43,6 +44,8 @@ export function composeHandoff(task, notRun = []) {
     return {
         outcome: { status: task.status, ...(task.reason ? { reason: task.reason } : {}), ...(task.stopCode ? { stopCode: task.stopCode } : {}) },
         changedFiles: (vcs.files ?? []).map((f) => ({ path: f.path, added: f.added, removed: f.removed })),
+        // With no commit, what changed is read from the tree: the paths, without line counts.
+        ...(task.treeChanged?.length ? { uncommittedFiles: task.treeChanged } : {}),
         validation: (task.checkResults ?? []).map((c) => ({ name: c.name, passed: c.passed })),
         ...(task.review
             ? { review: { verdict: task.review.verdict, open: openFindings.length, ...(task.review.skippedBecause ? { skippedBecause: task.review.skippedBecause } : {}) } }

package/dist/src/session/interruption.js

@@ -50,7 +50,9 @@ export async function readInterruption(runDir) {
         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';
+        // A step killed by a Stop is recorded as finished with outcome "aborted": it was cut off, not run to the end.
+        const cutShort = finished?.outcome === 'aborted';
+        const state = finished && !cutShort ? 'finished' : skipped ? 'skipped' : started || cutShort ? 'cut' : 'not-run';
         const step = { id, state };
         if (typeof proposed?.description === 'string')
             step.command = proposed.description;

package/dist/src/session/runLog.js

@@ -9,7 +9,7 @@
  * browser opens and read back by the runner export, which can then show that `browser-launch-requested`
  * came after `run-preflight-passed` — or that a refused run never asked for a browser at all.
  */
-import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { appendFile, mkdir, readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 /** A run id as a folder name: what the service makes (`r-…`, `b-…`), and nothing that walks out of `_runs`. */
 const safe = (runId) => runId.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 80);
@@ -58,3 +58,44 @@ export function browserAfterPreflight(entries) {
         browserOnlyAfterPreflight: browser < 0 ? null : passed >= 0 && passed < browser,
     };
 }
+/**
+ * The runs refused for a session before any task of it began: their logs are the only record of them,
+ * since a refused run is written on no task. Found by reading the run logs under `_runs`.
+ */
+export async function refusedRunsOf(runsDir, sessionId) {
+    const out = [];
+    const ids = await readdir(join(runsDir, '_runs')).catch(() => []);
+    for (const id of ids) {
+        const entries = await readRunLog(runsDir, id);
+        const refused = entries.some((e) => e.type === 'run-preflight-refused');
+        const browser = entries.some((e) => e.type === 'browser-launch-requested');
+        const mine = entries.some((e) => e.type === 'run-preflight-started' && Array.isArray(e.data?.sessions) && e.data.sessions.includes(sessionId));
+        // And a run that went ahead without this session, refused at its turn (`atTurn`).
+        const refusedMe = entries.some((e) => e.type === 'run-preflight-refused' && Array.isArray(e.data?.sessions) && e.data.sessions.includes(sessionId));
+        if ((refused && !browser && mine) || refusedMe)
+            out.push(id);
+    }
+    return out.sort();
+}
+/**
+ * A durable record of what the operator did to a session outside any run — a fix pressed on the run
+ * screen, the folder prepared from the remote. These change the repository or where the session starts,
+ * and were in nothing but the live event stream and git's reflog (live run 2026-10-03). One file per
+ * session, `<runs>/_sessions/<session id>/actions.jsonl`, read back by the runner export.
+ */
+export async function appendSessionLog(runsDir, sessionId, entry) {
+    const dir = join(runsDir, '_sessions', safe(sessionId));
+    await mkdir(dir, { recursive: true });
+    await appendFile(join(dir, 'actions.jsonl'), JSON.stringify({ at: new Date().toISOString(), ...entry }) + '\n', 'utf8');
+}
+export async function readSessionLog(runsDir, sessionId) {
+    const text = await readFile(join(runsDir, '_sessions', safe(sessionId), 'actions.jsonl'), 'utf8').catch(() => '');
+    return text.split('\n').filter((l) => l.trim()).flatMap((l) => {
+        try {
+            return [JSON.parse(l)];
+        }
+        catch {
+            return [];
+        }
+    });
+}

package/dist/src/session/runName.js

@@ -20,7 +20,9 @@ export function suggestRunName(all, sessionIds, about) {
     }
     theirs.sort((a, b) => b.at.localeCompare(a.at));
     const chosen = all.filter((s) => wanted.has(s.id));
-    const base = stripNumber(theirs[0]?.name ?? '') ||
+    // A name that only counted sessions is not carried on: "3 sessions #2" for a run of two (live run 2026-10-03).
+    const carried = stripNumber(theirs[0]?.name ?? '');
+    const base = (/^\d+ sessions$/.test(carried) ? '' : carried) ||
         (chosen.length === 1 ? chosen[0].name.trim() : '') ||
         (about ?? '').trim() ||
         // Nothing to go on: say what it is rather than leave it blank again.

package/dist/src/session/store.js

@@ -100,6 +100,7 @@ export const TASK_FIELD_ON_RERUN = {
     stopCode: 'archived',
     limit: 'archived',
     scopeReverted: 'archived',
+    treeChanged: 'archived',
     inputsRestored: 'archived',
     artifactsKept: 'archived',
     vcs: 'archived',
@@ -522,7 +523,9 @@ export class SessionStore {
      * on with it; those are run again — unless what ended them was a limit from the settings (out of
      * rounds of fixing checks or review findings), which is a counter, not the verdict. See `TaskLimit`.
      */
-    async continueTask(sessionId, taskId) {
+    async continueTask(sessionId, taskId, 
+    /** Where an attempt the operator stopped had got to, read from its run folder by the caller. */
+    stoppedAt) {
         const current = (await this.getSession(sessionId))?.tasks.find((x) => x.id === taskId);
         if (!current)
             throw new Error(`Task ${taskId} does not exist in session ${sessionId}.`);
@@ -535,7 +538,7 @@ export class SessionStore {
             stoppedBecause: current.reason,
             how,
             ...(current.limit ? { limit: current.limit } : {}),
-            ...(current.interruption ? { interruption: current.interruption } : {}),
+            ...(current.interruption ? { interruption: current.interruption } : how === 'stopped' && stoppedAt ? { interruption: stoppedAt } : {}),
         });
     }
     /**
@@ -587,6 +590,7 @@ export class SessionStore {
                     scope: t.scope,
                     readOnly: t.readOnly,
                     scopeReverted: t.scopeReverted,
+                    treeChanged: t.treeChanged,
                     handoff: t.handoff,
                     inputsRestored: t.inputsRestored,
                     artifactsKept: t.artifactsKept,
@@ -624,6 +628,7 @@ export class SessionStore {
             t.stats = undefined;
             t.handoff = undefined;
             t.scopeReverted = undefined;
+            t.treeChanged = undefined;
             t.inputsRestored = undefined;
             t.artifactsKept = undefined;
             t.freshRetry = undefined;