copilot-operator 0.1.17 → 0.1.19

package/dist/src/plan/schema.js

@@ -13,6 +13,8 @@
  * sending the user back to the chat; it is reported as a warning instead.
  */
 import { z } from 'zod';
+import { namesEverything } from '../vcs/inputs.js';
+import { coveredByArtifacts } from '../vcs/artifacts.js';
 export const PLAN_VERSION = 1;
 /**
  * Version control, exactly as a session stores it, and required on every session.
@@ -77,6 +79,35 @@ const VcsInput = z
             .optional(),
     })
         .optional(),
+    /**
+     * The operator's input files. See `UserInputs`. Accepts the spelling a chat model may write:
+     * `capture` can only be "baseline-commit", `allowUntracked`/`allowIgnored` only true (an input
+     * may be either), `readOnlyAfterCapture` is `readOnly`.
+     */
+    userInputs: z
+        .object({
+        enabled: z.boolean().optional(),
+        paths: z.array(z.string().trim()).default([]),
+        capture: z.literal('baseline-commit', { error: 'userInputs.capture can only be "baseline-commit": input files go into the commit the session starts from. Leave the field out.' }).optional(),
+        allowUntracked: z.literal(true, { error: 'userInputs.allowUntracked can only be true: an input file may be untracked. Leave the field out.' }).optional(),
+        allowIgnored: z.literal(true, { error: 'userInputs.allowIgnored can only be true: an input file may be ignored by git. Leave the field out.' }).optional(),
+        readOnly: z.boolean().optional(),
+        readOnlyAfterCapture: z.boolean().optional(),
+        requireApproval: z.boolean().optional(),
+    })
+        .optional(),
+    /**
+     * Evidence kept with the run and never committed. See `VersionControl.artifacts`. `commit` can
+     * only be false and `attachToRun`/`allowIgnored` only true: that is what an artifact is.
+     */
+    artifacts: z
+        .object({
+        paths: z.array(z.string().trim()).default([]),
+        allowIgnored: z.literal(true, { error: 'artifacts.allowIgnored can only be true. Leave the field out.' }).optional(),
+        attachToRun: z.literal(true, { error: 'artifacts.attachToRun can only be true: artifacts are always kept with the run. Leave the field out.' }).optional(),
+        commit: z.literal(false, { error: 'artifacts.commit can only be false: an artifact is never committed. Files that should be committed are the work, not artifacts.' }).optional(),
+    })
+        .optional(),
 }, {
     error: 'Every session needs a "vcs" object saying whether the runner does version control for it and, when it does, which git repository to work in. Ask the user both questions and write the answers here.',
 })
@@ -102,6 +133,23 @@ const VcsInput = z
             message: '"tracked-only-snapshot" takes tracked changes only, and includeUntracked true asks for new files too. Keep one: policy "snapshot", or leave includeUntracked out.',
         });
     }
+    for (const [i, p] of (vcs.userInputs?.paths ?? []).entries()) {
+        if (namesEverything(p)) {
+            ctx.addIssue({ code: 'custom', path: ['userInputs', 'paths', i], message: `"${p}" names the whole repository; an input pattern names the operator's files, such as "rules-engine/test-data/schemas/*.yaml".` });
+        }
+    }
+    if (vcs.userInputs && vcs.userInputs.enabled !== false && (vcs.userInputs.paths ?? []).length > 0 && !vcs.enabled) {
+        ctx.addIssue({ code: 'custom', path: ['userInputs'], message: 'userInputs needs version control on: the input files go into the commit the session starts from. Turn vcs.enabled on, or leave userInputs out.' });
+    }
+    const hidden = coveredByArtifacts(vcs.userInputs?.paths ?? [], vcs.artifacts?.paths ?? []);
+    if (hidden.length > 0) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['artifacts', 'paths'],
+            message: `An artifacts pattern covers the input files ${hidden.map((h) => `"${h}"`).join(', ')}: artifacts are kept out of git, so the inputs would be too. ` +
+                'Name only the folders the evidence is written to (for example "rules-engine/test-results/**"), not a whole project folder.',
+        });
+    }
     if (vcs.enabled && !vcs.repoDir.trim()) {
         ctx.addIssue({
             code: 'custom',
@@ -259,6 +307,11 @@ const TaskInput = z.object({
      * chat told — which a sentence in the prompt cannot be. See `vcs/scope.ts`.
      */
     scope: z.array(z.string().trim().min(1, 'A scope entry needs a path or a pattern.')).default([]),
+    /**
+     * Files the task is to produce as evidence (reports, archives), repository-relative patterns.
+     * Kept with the run's record when the task creates or changes them. See `Task.outputs`.
+     */
+    outputs: z.array(z.string().trim().min(1, 'An outputs entry needs a path or a pattern.')).default([]),
     /**
      * What earlier attempts of this task were asked, written by the plan export for a task that has
      * been run more than once (`earlierPlans` in `session/exports.ts`). History, not instruction:

package/dist/src/plan/systemGuide.js

@@ -1213,8 +1213,8 @@ export const SYSTEM_GUIDE = [
                         kind: 'note',
                         en: 'Uncommitted changes',
                         bg: 'Некомитнати промени',
-                        doesEn: 'What the first task does when the repository has uncommitted changes: keep version control out (as until now), or take them — all, or tracked only — as a starting snapshot: one commit on a branch of its own that the session starts from. In a plan: "dirtyWorktree": { "policy": "snapshot" }. Not shown for "Carry on an existing branch".',
-                        doesBg: 'Какво прави първата задача, когато хранилището има некомитнати промени: без контрол на версиите (както досега) или ги взема — всички или само tracked — като начална снимка: един комит на отделен клон, от който сесията тръгва. В план: "dirtyWorktree": { "policy": "snapshot" }. Не се показва при „Продължи съществуващ клон“.',
+                        doesEn: 'What the first task does when the repository has uncommitted changes: refuse to start until they are committed, or take them — all, or tracked only — as a starting snapshot: one commit on a branch of its own that the session starts from. In a plan: "dirtyWorktree": { "policy": "snapshot" }. Not shown for "Carry on an existing branch".',
+                        doesBg: 'Какво прави първата задача, когато хранилището има некомитнати промени: отказва старта, докато не са комитнати, или ги взема — всички или само tracked — като начална снимка: един комит на отделен клон, от който сесията тръгва. В план: "dirtyWorktree": { "policy": "snapshot" }. Не се показва при „Продължи съществуващ клон“.',
                     },
                     {
                         key: 'vcs.snapshotTake',
@@ -1224,6 +1224,46 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'Under the list of uncommitted files, each set to "Include in the starting snapshot" or "Leave out of the run": commits the included ones on the snapshot branch; left-out files go to the repository\'s .git/info/exclude. Until it is pressed a run of the session is refused and nothing changes.',
                         doesBg: 'Под списъка с некомитнати файлове, всеки с „Включи в началната снимка“ или „Остави извън изпълнението“: комитва включените на клона на снимката; оставените извън отиват в .git/info/exclude на хранилището. Докато не е натиснат, пускане на сесията се отказва и нищо не се променя.',
                     },
+                    {
+                        key: 'vcs.inputs',
+                        kind: 'note',
+                        en: 'Input files',
+                        bg: 'Входни файлове',
+                        doesEn: 'The heading over the operator\'s input files and whether they are read-only.',
+                        doesBg: 'Заглавието над входните файлове на оператора и дали са само за четене.',
+                    },
+                    {
+                        key: 'vcs.inputsField',
+                        kind: 'field',
+                        en: 'Your input files, one pattern per line (repository-relative)',
+                        bg: 'Твоите входни файлове, по един шаблон на ред (спрямо хранилището)',
+                        doesEn: 'Files the operator provides — schemas, test data. They go into the commit every session of the run starts from (new or ignored ones in the starting snapshot, listed for approval); a later session whose start lacks them has them committed on top of it; their SHA-256 sums are recorded. In a plan: "userInputs": { "paths": [...] }.',
+                        doesBg: 'Файлове, които операторът дава — схеми, тестови данни. Влизат в комита, от който тръгва всяка сесия на пускането (новите или ignored — в началната снимка, със списък за одобрение); следваща сесия, чието начало ги няма, ги получава комитнати върху него; SHA-256 сумите им се записват. В план: "userInputs": { "paths": [...] }.',
+                    },
+                    {
+                        key: 'vcs.inputsReadOnly',
+                        kind: 'checkbox',
+                        en: 'Read-only while the tasks run',
+                        bg: 'Само за четене, докато задачите работят',
+                        doesEn: 'On by default. A changed, deleted or added input file is put back after every round and the chat told; one that cannot be put back fails the task.',
+                        doesBg: 'Включено по подразбиране. Променен, изтрит или добавен входен файл се връща след всеки рунд и чатът научава; такъв, който не може да се върне, проваля задачата.',
+                    },
+                    {
+                        key: 'vcs.artifacts',
+                        kind: 'note',
+                        en: 'Artifacts',
+                        bg: 'Artifacts',
+                        doesEn: 'The heading over the evidence files the work writes.',
+                        doesBg: 'Заглавието над файловете с доказателства, които работата пише.',
+                    },
+                    {
+                        key: 'vcs.artifactsField',
+                        kind: 'field',
+                        en: 'Evidence the work writes, one pattern per line (repository-relative)',
+                        bg: 'Доказателства, които работата пише, по един шаблон на ред (спрямо хранилището)',
+                        doesEn: 'Reports, ZIP archives, test results: never committed (kept out through .git/info/exclude, .gitignore untouched) and copied into each attempt\'s record with their sums. In a plan: "artifacts": { "paths": [...] }.',
+                        doesBg: 'Отчети, ZIP архиви, резултати от тестове: никога не се комитват (стоят извън git чрез .git/info/exclude, .gitignore не се пипа) и се копират към записа на всеки опит със сумите си. В план: "artifacts": { "paths": [...] }.',
+                    },
                     {
                         key: 'vcs.ready',
                         kind: 'note',
@@ -3201,6 +3241,14 @@ export const SYSTEM_GUIDE = [
                 en: 'This machine',
                 bg: 'Тази машина',
                 controls: [
+                    {
+                        key: 'sys.version',
+                        kind: 'note',
+                        en: 'copilot-operator version',
+                        bg: 'Версия на copilot-operator',
+                        doesEn: 'The first row: which version of the bot is running, as `cop --version` says. Name it when reporting a problem.',
+                        doesBg: 'Първият ред: коя версия на бота работи, както я казва `cop --version`. Кажи я, когато съобщаваш за проблем.',
+                    },
                     {
                         key: 'sys.signin',
                         kind: 'note',

package/dist/src/protocol/replySchema.js

@@ -83,7 +83,7 @@ export const DeviationSchema = z.object({
  * claim to test, and to the record. The finding is named by the id the runner gave it.
  */
 export const DisputeSchema = z.object({
-    /** The finding's id as it was given: `r1f2`. */
+    /** The finding's id as it was given: `r1f2`, or `a2r1f2` on a later attempt. */
     finding: z.string().trim().min(1),
     /** Why it is wrong. */
     why: z.string().trim().min(1),

package/dist/src/protocol/reviewSchema.js

@@ -166,13 +166,18 @@ export function isGrounded(basis, sources) {
     return sources.some((s) => groundingKey(s).includes(key));
 }
 /**
- * The name a finding is referred to by, once the runner has it: round and position.
+ * The name a finding is referred to by, once the runner has it: round and position, and from the
+ * task's second attempt on the attempt as well — `r1f2`, then `a2r1f2`.
  *
- * Given by the runner rather than the reviewer so that it is unique across rounds and cannot
- * be forgotten. It is what the implementer names in `disputed`, and what the record shows.
+ * Given by the runner rather than the reviewer so that it is unique and cannot be forgotten. It is
+ * what the implementer names in `disputed`, what a check given with the finding is named after, and
+ * what the record shows. Unique across the task's attempts, not only its rounds, because those checks
+ * are kept for every later attempt (`Task.reviewChecks`) and the rounds count from 1 on each: with
+ * round and position alone, attempt 2's first finding was `r1f1` beside attempt 1's kept `r1f1`, and
+ * a dispute of the one suspended the check of the other. The first attempt keeps the short form.
  */
-export function findingId(round, index) {
-    return `r${round}f${index + 1}`;
+export function findingId(round, index, attempt = 1) {
+    return `${attempt > 1 ? `a${attempt}` : ''}r${round}f${index + 1}`;
 }
 /** True when nothing the reviewer found is something the implementer could fix. */
 export function allAboutTheTask(findings) {

package/dist/src/session/exports.js

@@ -21,6 +21,8 @@
 import { existsSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { TASK_FIELD_ON_RERUN } from './store.js';
+import { botVersion } from '../config/version.js';
 import { withoutPersona } from '../plan/importPlan.js';
 const EXPECTED_HEADER = '### Expected result';
 const GOAL_HEADER = '## Goal of this session';
@@ -149,6 +151,8 @@ export function buildPlanExport(scope) {
                     ...(s.vcs?.updateFromRemote === false ? { updateFromRemote: false } : {}),
                     // Only when chosen: absent is reject, as it always was.
                     ...(s.vcs?.dirtyWorktree && s.vcs.dirtyWorktree.policy !== 'reject' ? { dirtyWorktree: { ...s.vcs.dirtyWorktree } } : {}),
+                    ...(s.vcs?.userInputs?.paths.length ? { userInputs: { ...s.vcs.userInputs } } : {}),
+                    ...(s.vcs?.artifacts?.paths.length ? { artifacts: { ...s.vcs.artifacts } } : {}),
                 },
                 review: { enabled: s.review?.enabled !== false, model: s.review?.model ?? '' },
                 ...(s.projectDir ? { projectDir: s.projectDir } : {}),
@@ -168,6 +172,8 @@ export function buildPlanExport(scope) {
                         task.readOnly = true;
                     if (t.scope && t.scope.length > 0)
                         task.scope = [...t.scope];
+                    if (t.outputs && t.outputs.length > 0)
+                        task.outputs = [...t.outputs];
                     const earlier = earlierPlans(t, level2);
                     if (earlier.length > 0)
                         task.earlierAttempts = earlier;
@@ -231,27 +237,32 @@ export function taskAtAttempt(task, attempt) {
     const a = task.attempts?.[attempt - 1];
     if (!a)
         return null;
+    /*
+     * By the same table `rerunTask` follows: what was archived is read from the attempt, what was
+     * cleared is absent. Field by field, by hand, an earlier attempt read back with the latest one's
+     * handoff, counts, limit and fresh-chat mark.
+     */
+    const asItWas = {};
+    for (const [key, what] of Object.entries(TASK_FIELD_ON_RERUN)) {
+        if (what === 'archived')
+            asItWas[key] = a[key];
+        if (what === 'cleared')
+            asItWas[key] = undefined;
+    }
     return {
         ...task,
+        ...asItWas,
         attempt,
         status: a.status,
-        runId: a.runId,
-        runGroup: a.runGroup,
-        startedAt: a.startedAt,
-        finishedAt: a.finishedAt,
         iterations: a.iterations,
-        summary: a.summary,
-        reason: a.reason,
-        deviations: a.deviations,
-        disputes: a.disputes,
+        // The task's own text and definition as they were when that attempt ran, where it was kept.
         title: a.title,
         prompt: a.prompt,
         level2: a.level2,
         checks: a.checks ?? task.checks,
         vcsPlan: a.vcsPlan ?? task.vcsPlan,
-        checkResults: a.checkResults,
-        review: a.review,
-        vcs: a.vcs,
+        scope: a.scope ?? task.scope,
+        readOnly: a.readOnly ?? task.readOnly,
         attempts: task.attempts?.slice(0, attempt - 1),
         continuing: undefined,
         buildsOn: undefined,
@@ -436,7 +447,25 @@ async function domainTask(session, task, runsDir) {
     const started = task.startedAt ? Date.parse(task.startedAt) : NaN;
     const finished = task.finishedAt ? Date.parse(task.finishedAt) : NaN;
     const out = {
-        session: { id: session.id, name: session.name },
+        /*
+         * Where the session started — the baseline commit, a snapshot of the operator's changes, the
+         * input files with their SHA-256 sums — so a reader can check the work against its inputs.
+         */
+        session: {
+            id: session.id,
+            name: session.name,
+            ...(session.vcsStart
+                ? {
+                    start: {
+                        kind: session.vcsStart.kind,
+                        commit: session.vcsStart.commit,
+                        branch: session.vcsStart.branch,
+                        ...(session.vcsStart.snapshot ? { snapshot: session.vcsStart.snapshot } : {}),
+                        ...(session.vcsStart.inputs ? { inputs: session.vcsStart.inputs } : {}),
+                    },
+                }
+                : {}),
+        },
         task: {
             id: task.id,
             title: task.title,
@@ -444,6 +473,8 @@ async function domainTask(session, task, runsDir) {
             readOnly: task.readOnly ?? false,
             scope: task.scope ?? [],
             scopeReverted: task.scopeReverted ?? [],
+            inputsRestored: task.inputsRestored ?? [],
+            artifactsKept: task.artifactsKept ?? [],
             handoff: task.handoff ?? null,
             stopCode: task.stopCode ?? null,
             prompt: p.prompt,
@@ -526,7 +557,7 @@ async function domainTask(session, task, runsDir) {
                 whatTheChatTried: aRounds,
                 whatWasActuallyDone: { repository: a.vcs, deviations: a.deviations, disputes: a.disputes },
                 whyItFailed: aFailed
-                    ? { status: a.status, reason: a.reason, failingChecks: (a.checkResults ?? []).filter((c) => !c.passed), lastRound: aRounds.at(-1) }
+                    ? { status: a.status, reason: a.reason, failingChecks: (a.checkResults ?? []).filter((c) => !c.passed), lastRound: aRounds.at(-1), leftovers: a.leftovers }
                     : undefined,
             });
         }
@@ -550,6 +581,8 @@ export async function buildDomainExport(scope, runsDir) {
     }
     return {
         exportedAt: new Date().toISOString(),
+        // Which copilot-operator made this, so a report from another machine says it without being asked.
+        botVersion: botVersion(),
         about: `copilot-operator, the work: ${scope.label}. What each task asked, what the chat tried, what was done to the repository, and why a task did not end done. Nothing about the runner itself; that is the bot export.`,
         counts,
         tasks,
@@ -607,6 +640,9 @@ async function botTask(session, task, runsDir) {
                 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),
                 events: aEvents.map(trimmed),
+                // That attempt's own: what it left running and the machine it ran on.
+                processes: { leftovers: a.leftovers },
+                environment: a.environment,
             };
         })),
     };
@@ -618,6 +654,8 @@ export async function buildBotExport(scope, runsDir, machine) {
         tasks.push(await botTask(session, task, runsDir));
     return {
         exportedAt: new Date().toISOString(),
+        // Which copilot-operator made this, so a report from another machine says it without being asked.
+        botVersion: botVersion(),
         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,
         tasks,
@@ -649,6 +687,8 @@ export async function buildBundleExport(scope, runsDir, machine) {
     const pairs = tasksOf(scope);
     return {
         exportedAt: new Date().toISOString(),
+        // Which copilot-operator made this, so a report from another machine says it without being asked.
+        botVersion: botVersion(),
         about: `copilot-operator, all three views of ${pairs.length} chosen task(s): ${scope.label}. ` +
             '`plan` is what was asked, in the format that imports again; `work` is what happened to it; ' +
             '`runner` is what the machine did. Read `work` first, then `runner` when the machine is the suspect.',

package/dist/src/session/model.js

@@ -21,6 +21,26 @@ export function tidyVcsPlan(plan) {
 export function isContinuable(t) {
     return t.status === 'limit-reached' || t.status === 'aborted' || (!!t.limit && (t.status === 'failed' || t.status === 'blocked'));
 }
+/**
+ * How many times the runner ran the task again in a fresh conversation, on its own, in the run that
+ * produced its latest attempt (`limits.retryBlockedInFreshChat`): the attempts at the end of its
+ * history that it marked `freshRetry`, counted back to the one the operator started. A row that says
+ * "retried in a fresh chat, then done" means the chat was the cause; "still blocked after 2" means
+ * it was not.
+ *
+ * Derived, never stored. It was a counter on the task that the runner added to and nothing reset,
+ * so every Run again or Continue of a task that blocked added the run's retries to the last run's:
+ * the register said 2, then 4, then 6, while each run had retried twice.
+ */
+export function freshRetriesOfLatestRun(task) {
+    if (!task.freshRetry)
+        return 0;
+    let n = 1;
+    const before = task.attempts ?? [];
+    for (let i = before.length - 1; i >= 0 && before[i]?.freshRetry; i -= 1)
+        n += 1;
+    return n;
+}
 export function newId(prefix = '') {
     const now = new Date();
     const p = (n) => String(n).padStart(2, '0');

package/dist/src/session/store.js

@@ -50,6 +50,67 @@ export function bySessionList(a, b) {
         return byTime;
     return b.id.localeCompare(a.id);
 }
+/**
+ * What `rerunTask` does with every field of a task when a new attempt begins — Run again, Continue,
+ * a new prompt, the runner's own fresh-chat retry.
+ *
+ *   archived  belongs to the attempt that ended: copied onto its `TaskAttempt`, cleared on the task
+ *   cleared   belongs to that attempt and is not kept on the record: cleared
+ *   reset     given the new attempt's starting value (status queued, iterations 0, attempt + 1, …)
+ *   kept      the task's own, across attempts: its definition, or something every attempt inherits
+ *
+ * A record over every key of `Task`, so a field added to the task without a decision here does not
+ * compile. Fields that were left out of `rerunTask` by default were counted on by the next attempt:
+ * the fresh-chat retry count said 2, then 4, then 6 while each run had retried twice, and what an
+ * attempt left running was listed under every attempt after it. `npm run check:attempts` holds
+ * `rerunTask` to this table.
+ */
+export const TASK_FIELD_ON_RERUN = {
+    id: 'kept',
+    title: 'kept',
+    level2: 'kept',
+    prompt: 'kept',
+    createdAt: 'kept',
+    checks: 'kept',
+    vcsPlan: 'kept',
+    reviewEnabled: 'kept',
+    readOnly: 'kept',
+    scope: 'kept',
+    outputs: 'kept',
+    // What one review noticed is arithmetic for every attempt after it.
+    reviewChecks: 'kept',
+    attempts: 'kept',
+    status: 'reset',
+    iterations: 'reset',
+    attempt: 'reset',
+    continuing: 'reset',
+    buildsOn: 'reset',
+    runId: 'archived',
+    runGroup: 'archived',
+    startedAt: 'archived',
+    finishedAt: 'archived',
+    summary: 'archived',
+    reason: 'archived',
+    deviations: 'archived',
+    disputes: 'archived',
+    checkResults: 'archived',
+    review: 'archived',
+    stats: 'archived',
+    freshRetry: 'archived',
+    stopCode: 'archived',
+    limit: 'archived',
+    scopeReverted: 'archived',
+    inputsRestored: 'archived',
+    artifactsKept: 'archived',
+    vcs: 'archived',
+    leftovers: 'archived',
+    environment: 'archived',
+    handoff: 'archived',
+    interruption: 'cleared',
+    finalReply: 'cleared',
+    firstMessage: 'cleared',
+    logFile: 'cleared',
+};
 export const DEFAULT_VCS = {
     enabled: true,
     repoDir: '',
@@ -408,6 +469,7 @@ export class SessionStore {
             ...(input.readOnly === true ? { readOnly: true } : {}),
             // Stored only when it limits something: absent means anywhere, as before scopes existed.
             ...((input.scope ?? []).filter((p) => p.trim()).length > 0 ? { scope: (input.scope ?? []).map((p) => p.trim()).filter(Boolean) } : {}),
+            ...((input.outputs ?? []).filter((p) => p.trim()).length > 0 ? { outputs: (input.outputs ?? []).map((p) => p.trim()).filter(Boolean) } : {}),
         };
         await this.updateSession(sessionId, (s) => {
             s.tasks.push(task);
@@ -476,6 +538,9 @@ export class SessionStore {
             ...(current.interruption ? { interruption: current.interruption } : {}),
         });
     }
+    /**
+     * What a new attempt does with each field of a task — see `TASK_FIELD_ON_RERUN`.
+     */
     async rerunTask(sessionId, taskId, patch = {}, 
     /** Present when the new attempt carries on from the last one (see `continueTask`). */
     continuing, 
@@ -495,6 +560,8 @@ export class SessionStore {
                 {
                     runId: t.runId,
                     runGroup: t.runGroup,
+                    leftovers: t.leftovers,
+                    environment: t.environment,
                     status: t.status,
                     startedAt: t.startedAt,
                     finishedAt: t.finishedAt,
@@ -518,7 +585,11 @@ export class SessionStore {
                     stopCode: t.stopCode,
                     limit: t.limit,
                     scope: t.scope,
+                    readOnly: t.readOnly,
                     scopeReverted: t.scopeReverted,
+                    handoff: t.handoff,
+                    inputsRestored: t.inputsRestored,
+                    artifactsKept: t.artifactsKept,
                     vcs: t.vcs,
                 },
             ];
@@ -553,9 +624,15 @@ export class SessionStore {
             t.stats = undefined;
             t.handoff = undefined;
             t.scopeReverted = undefined;
+            t.inputsRestored = undefined;
+            t.artifactsKept = undefined;
             t.freshRetry = undefined;
             t.stopCode = undefined;
             t.limit = undefined;
+            // What this attempt left running and the machine it ran on are this attempt's, as the rest:
+            // left in place, the next attempt's list was added to this one's and read as its own.
+            t.leftovers = undefined;
+            t.environment = undefined;
             // The branch of the finished attempt stays in the repository and stays on the record
             // above; the next attempt gets its own, cut from the same commit this one started at.
             t.vcs = undefined;
@@ -618,6 +695,9 @@ export class SessionStore {
             // Sessions written before the queue could be told what to do on a failure behave the
             // way they always did: the chain stops.
             s.onFailure ??= 'stop';
+            // A counter that added up across runs, written before it was derived (`freshRetriesOfLatestRun`).
+            for (const t of s.tasks ?? [])
+                delete t.autoRetries;
             return s;
         }
         catch {