copilot-operator 0.1.16 → 0.1.18

package/dist/src/plan/systemGuide.js

@@ -827,6 +827,22 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'Deletes every session ticked in the first column after one question, also during a run; never the one running. Run folders and chats survive.',
                         doesBg: 'Изтрива всички отметнати в първата колона сесии след един въпрос, и по време на пускане; никога работещата. Папките и разговорите остават.',
                     },
+                    {
+                        key: 'home.moveUp',
+                        kind: 'button',
+                        en: 'Move {name} up in the list',
+                        bg: 'Премести {name} нагоре в списъка',
+                        doesEn: 'The ↑ arrow in the Order column: one place up. ↓ is one place down. Dragging a row onto another moves it there. An imported plan comes in on top in its own order.',
+                        doesBg: 'Стрелката ↑ в колона „Ред“: едно място нагоре. ↓ е едно надолу. Плъзгане на ред върху друг го мести там. Импортиран план идва най-отгоре в своя ред.',
+                    },
+                    {
+                        key: 'home.moveDown',
+                        kind: 'button',
+                        en: 'Move {name} down in the list',
+                        bg: 'Премести {name} надолу в списъка',
+                        doesEn: 'The ↓ arrow in the Order column: one place down. A run of several takes the ticked sessions top to bottom.',
+                        doesBg: 'Стрелката ↓ в колона „Ред“: едно място надолу. Пускане на няколко взима отметнатите сесии отгоре надолу.',
+                    },
                     {
                         key: 'home.delete',
                         kind: 'button',
@@ -1192,6 +1208,62 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'One local commit per task whatever the outcome; unticked leaves the changes loose in the working tree.',
                         doesBg: 'По един локален комит на задача, независимо от изхода; без отметка промените остават свободни в работното дърво.',
                     },
+                    {
+                        key: 'vcs.dirty',
+                        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" }. Не се показва при „Продължи съществуващ клон“.',
+                    },
+                    {
+                        key: 'vcs.snapshotTake',
+                        kind: 'button',
+                        en: 'Take the starting snapshot',
+                        bg: 'Направи началната снимка',
+                        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',

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,7 @@
 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 { withoutPersona } from '../plan/importPlan.js';
 const EXPECTED_HEADER = '### Expected result';
 const GOAL_HEADER = '## Goal of this session';
@@ -147,6 +148,10 @@ export function buildPlanExport(scope) {
                     ...(s.vcs?.existingBranch ? { existingBranch: s.vcs.existingBranch } : {}),
                     // Only when switched off: absent is on.
                     ...(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 } : {}),
@@ -229,27 +234,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,
@@ -434,7 +444,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,
@@ -442,6 +470,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,
@@ -524,7 +554,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,
             });
         }
@@ -605,6 +635,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,
             };
         })),
     };

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

@@ -29,6 +29,87 @@ const ACTIVE_STATUSES = ['running', 'waiting-approval'];
  * feature works at all would mean most runs go unreviewed.
  */
 export const DEFAULT_REVIEW = { enabled: true, model: '' };
+/**
+ * Where a session sits in the list: its position, or, for one saved before the list could be
+ * arranged, minus the time it was created — which keeps those newest first, as they always were,
+ * and above any arranged session only if they are newer than the list's top was.
+ */
+export function sessionListKey(s) {
+    if (typeof s.position === 'number' && Number.isFinite(s.position))
+        return s.position;
+    const t = Date.parse(s.createdAt);
+    return Number.isNaN(t) ? 0 : -t;
+}
+/** The sessions list's order: by position, then newest first, then by id so it never wobbles. */
+export function bySessionList(a, b) {
+    const byKey = sessionListKey(a) - sessionListKey(b);
+    if (byKey !== 0)
+        return byKey;
+    const byTime = Date.parse(b.createdAt) - Date.parse(a.createdAt);
+    if (byTime !== 0 && !Number.isNaN(byTime))
+        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',
+    // 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: '',
@@ -254,12 +335,50 @@ export class SessionStore {
             if (s)
                 out.push(s);
         }
-        return out.sort((a, b) => {
-            const byTime = Date.parse(b.createdAt) - Date.parse(a.createdAt);
-            if (byTime !== 0 && !Number.isNaN(byTime))
-                return byTime;
-            return b.id.localeCompare(a.id);
-        });
+        return out.sort(bySessionList);
+    }
+    /**
+     * Puts these sessions at the top of the list, in this order.
+     *
+     * An import calls it with the plan's sessions, so they appear as the plan wrote them. Before
+     * this, the list was newest first, and a plan whose sessions were created one after another
+     * read upside down.
+     */
+    async placeOnTop(ids) {
+        const wanted = new Set(ids);
+        const others = (await this.listSessions()).filter((s) => !wanted.has(s.id));
+        const top = others.length > 0 ? Math.min(...others.map(sessionListKey)) : 0;
+        for (const [i, id] of ids.entries()) {
+            await this.updateSession(id, (s) => {
+                s.position = top - ids.length + i;
+            });
+        }
+    }
+    /**
+     * The operator's own order: every session, top to bottom.
+     *
+     * The whole list is given, not one move, so two pages moving rows at once cannot leave positions
+     * that contradict each other: the last order sent is the order there is. A list that names a
+     * session that does not exist, or leaves one out, is refused rather than guessed at.
+     */
+    async reorderSessions(ids) {
+        const all = await this.listSessions();
+        const known = new Set(all.map((s) => s.id));
+        const given = new Set(ids);
+        if (given.size !== ids.length)
+            throw new Error('The order names a session twice.');
+        const unknown = ids.filter((id) => !known.has(id));
+        if (unknown.length > 0)
+            throw new Error(`The order names a session that does not exist: ${unknown.join(', ')}.`);
+        const missing = all.filter((s) => !given.has(s.id)).map((s) => s.name);
+        if (missing.length > 0)
+            throw new Error(`The order leaves out ${missing.length} session(s): ${missing.slice(0, 5).join(', ')}. Reload the list and try again.`);
+        for (const [i, id] of ids.entries()) {
+            await this.updateSession(id, (s) => {
+                s.position = i;
+            });
+        }
+        return await this.listSessions();
     }
     /**
      * The session of this id, or null when there is none.
@@ -282,10 +401,13 @@ export class SessionStore {
         return await this.readSession(path);
     }
     async createSession(name, projectDir = '') {
+        // A new session goes on top of the list, where it is looked for.
+        const existing = await this.listSessions();
         const session = {
             id: newId(),
             name: name.trim() || 'untitled',
             createdAt: new Date().toISOString(),
+            position: existing.length > 0 ? Math.min(...existing.map(sessionListKey)) - 1 : 0,
             status: 'idle',
             contractSent: false,
             // A queue is a chain until the operator says otherwise, which is how it has always
@@ -414,6 +536,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, 
@@ -433,6 +558,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,
@@ -456,7 +583,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,
                 },
             ];
@@ -491,9 +622,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;
@@ -556,6 +693,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 {

package/dist/src/vcs/artifacts.js

@@ -0,0 +1,138 @@
+/**
+ * Evidence the work produces — reports, ZIP archives, test results — kept with the run, not in git.
+ *
+ * Found in a real run: evidence a task wrote was either committed with the work or, to stop that,
+ * `.gitignore` had to be changed for it, and a later session that needed an earlier one's discovery
+ * report had nothing reliable to read. `vcs.artifacts.paths` names those files, and:
+ *
+ *   - they are never committed: the patterns go into the repository's own `.git/info/exclude`
+ *     (local, never committed, `.gitignore` untouched) when the session's first task starts, so the
+ *     runner's commit and a task's scope both leave them alone. A file git already tracks is not
+ *     affected by an exclude, and is said so;
+ *   - when each task ends, whatever its outcome, the files are copied into the attempt's record,
+ *     `artifacts/project/<path>`, with their sizes and SHA-256 sums on the task — so the evidence of
+ *     each attempt is kept even after a later one overwrites it in the project.
+ *
+ * Works with version control off too: then nothing is excluded, only kept.
+ */
+import { createHash } from 'node:crypto';
+import { copyFile, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve, sep } from 'node:path';
+import { looksGenerated } from './commitHygiene.js';
+import { git } from './git.js';
+import { normalisePatterns } from './inputs.js';
+import { inScope } from './scope.js';
+/** The session's artifact patterns, without ones that name the whole project. */
+export function artifactPatterns(vcs) {
+    return normalisePatterns(vcs?.artifacts?.paths ?? []);
+}
+/** A pattern for `.git/info/exclude`: anchored at the repository's top, as a scope pattern is. */
+function excludeLine(pattern) {
+    return `/${pattern.replace(/^\/+/, '')}`;
+}
+/**
+ * Writes the session's artifact patterns into `.git/info/exclude`, once each. Returns the files
+ * matching them that git already tracks, which an exclude does not stop from being committed.
+ */
+export async function excludeArtifacts(dir, session) {
+    const patterns = artifactPatterns(session.vcs);
+    if (patterns.length === 0)
+        return { tracked: [] };
+    const where = await git(dir, ['rev-parse', '--git-path', 'info/exclude']);
+    if (!where.ok || !where.stdout)
+        return { problem: "the repository's exclude file could not be found", tracked: [] };
+    const top = (await git(dir, ['rev-parse', '--show-toplevel'])).stdout || dir;
+    const file = resolve(dir, where.stdout);
+    const before = await readFile(file, 'utf8').catch(() => '');
+    const have = new Set(before.split(/\r?\n/).map((l) => l.trim()));
+    const add = patterns.map(excludeLine).filter((l) => !have.has(l));
+    if (add.length > 0) {
+        try {
+            await mkdir(dirname(file), { recursive: true });
+            const block = [`# copilot-operator: artifacts of session "${session.name.replace(/[\r\n]+/g, ' ')}" (${session.id}) — kept with the run, never committed`, ...add, ''].join('\n');
+            await writeFile(file, `${before}${before && !before.endsWith('\n') ? '\n' : ''}${block}`, 'utf8');
+        }
+        catch (e) {
+            return { problem: `the exclude file could not be written: ${e.message}`, tracked: [] };
+        }
+    }
+    const tracked = (await git(resolve(top), ['ls-files'])).stdout.split('\n').filter((p) => p && inScope(p, patterns));
+    return { tracked };
+}
+const LIMITS = { files: 1000, fileBytes: 100 * 1024 * 1024, totalBytes: 500 * 1024 * 1024 };
+/** Files under `root` matching the patterns, found on disk: git's view does not matter for evidence. */
+async function matching(root, patterns) {
+    const out = [];
+    const starts = new Set(patterns.map((p) => {
+        const fixed = [];
+        for (const part of p.replace(/\/+$/, '').split('/')) {
+            if (/[*?[]/.test(part))
+                break;
+            fixed.push(part);
+        }
+        return fixed.join('/');
+    }));
+    const walk = async (rel) => {
+        if (out.length > LIMITS.files * 2)
+            return;
+        const abs = join(root, rel);
+        const info = await stat(abs).catch(() => null);
+        if (!info)
+            return;
+        if (info.isFile()) {
+            if (inScope(rel, patterns))
+                out.push(rel);
+            return;
+        }
+        if (!info.isDirectory())
+            return;
+        const name = rel.split('/').pop() ?? '';
+        if (name === '.git' || name === 'node_modules' || name === '.copilot-operator')
+            return;
+        for (const child of await readdir(abs).catch(() => []))
+            await walk(rel ? `${rel}/${child}` : child);
+    };
+    for (const start of starts)
+        await walk(start);
+    return [...new Set(out)].sort();
+}
+/**
+ * Copies the artifact files into the attempt's record, `<dest>/<path>`. Secrets are never copied;
+ * past the limits the rest is skipped and said.
+ */
+export async function keepArtifacts(root, patterns, dest) {
+    const kept = [];
+    const skipped = [];
+    if (patterns.length === 0 || !root)
+        return { kept, skipped };
+    let total = 0;
+    const base = resolve(root);
+    for (const rel of await matching(root, patterns)) {
+        const from = resolve(join(root, rel));
+        if (!from.startsWith(base + sep))
+            continue;
+        if (looksGenerated(rel)?.reason === 'a secrets file') {
+            skipped.push(`${rel} (a secrets file)`);
+            continue;
+        }
+        const info = await stat(from).catch(() => null);
+        if (!info)
+            continue;
+        if (kept.length >= LIMITS.files || info.size > LIMITS.fileBytes || total + info.size > LIMITS.totalBytes) {
+            skipped.push(`${rel} (past the limit of ${LIMITS.files} files, ${LIMITS.fileBytes / 1048576} MB a file, ${LIMITS.totalBytes / 1048576} MB in all)`);
+            continue;
+        }
+        const to = join(dest, rel);
+        try {
+            await mkdir(dirname(to), { recursive: true });
+            await copyFile(from, to);
+            const bytes = await readFile(to);
+            kept.push({ path: rel, size: bytes.length, sha256: createHash('sha256').update(bytes).digest('hex') });
+            total += info.size;
+        }
+        catch (e) {
+            skipped.push(`${rel} (${e.message})`);
+        }
+    }
+    return { kept, skipped };
+}