copilot-operator 0.1.18 → 0.1.20

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

@@ -47,6 +47,8 @@ import { composeHandoff } from '../session/handoff.js';
 import { planSync } from '../vcs/syncCommand.js';
 import { dirtyPolicy, takeSnapshot } from '../vcs/snapshot.js';
 import { normalisePatterns } from '../vcs/inputs.js';
+import { coveredByArtifacts } from '../vcs/artifacts.js';
+import { botVersion } from '../config/version.js';
 import { computeMetrics } from '../session/metrics.js';
 import { resolveDesktopDir, desktopIsSynced } from '../context/desktopDir.js';
 import { saveAndReveal } from './saveToDesktop.js';
@@ -436,6 +438,12 @@ let OperatorService = class OperatorService {
                     delete merged.artifacts;
                 else
                     merged.artifacts = { paths: artifactPaths };
+                // Artifacts are kept out of git; one that covers the input files would keep them out too.
+                const hidden = coveredByArtifacts(merged.userInputs?.paths ?? [], artifactPaths);
+                if (hidden.length > 0) {
+                    throw new Error(`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, not a whole project folder.');
+                }
                 // New inputs are settled again at the next task: the recorded ones are no longer the whole list.
                 if (JSON.stringify(merged.userInputs ?? null) !== JSON.stringify(s.vcs?.userInputs ?? null) && s.vcsStart?.inputs) {
                     s.vcsStart = { ...s.vcsStart, inputs: undefined };
@@ -2658,6 +2666,8 @@ let OperatorService = class OperatorService {
         const edge = ['C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe', 'C:/Program Files/Microsoft/Edge/Application/msedge.exe'].find((p) => existsSync(p));
         const holders = findEdgeUsingProfile(cfg.resolved.profileDir);
         return {
+            // Which copilot-operator this is: `cop --version` without a terminal.
+            version: botVersion(),
             node: process.versions.node,
             edge: edge ?? null,
             profileDir: cfg.resolved.profileDir,

package/dist/src/cli.js

@@ -24,32 +24,14 @@ import { PolicyLockUnusableError } from './config/lockedPolicy.js';
 import { EventBus } from './session/events.js';
 import { terminalAuthorizer, unattendedAuthorizer } from './exec/authorizer.js';
 import { unattendedPrecondition } from './exec/policy.js';
-import { botRootDir, isOwnCheckout } from './exec/workDir.js';
+import { isOwnCheckout } from './exec/workDir.js';
 import { desktopIsSynced, resolveDesktopDir } from './context/desktopDir.js';
 import { Url } from './transport/locators.js';
+import { botVersion } from './config/version.js';
 import { findEdgeUsingProfile } from './transport/profileLock.js';
 import { assessIsolation, readIsolationSignals } from './exec/isolation.js';
-/**
- * The version of the copilot-operator that is running, from its own package.json.
- *
- * It was a literal, '0.1.0', and stayed that through thirteen releases, so a bug report's
- * `cop --version` named a version that never had the bug. Read where the code is — `src/` under
- * tsx, `dist/src/` in a clone, `node_modules/copilot-operator/dist/src/` once installed — so it
- * cannot drift from what npm installed. botRootDir() falls back to the working directory when it
- * finds no package.json of ours, and that one is the user's project's: its version is not ours to
- * print, so the name is checked and anything else says "unknown".
- */
-function ownVersion() {
-    try {
-        const pkg = JSON.parse(readFileSync(join(botRootDir(), 'package.json'), 'utf8'));
-        if (pkg.name === 'copilot-operator' && typeof pkg.version === 'string' && pkg.version)
-            return pkg.version;
-    }
-    catch {
-        // No readable package.json: say so rather than guess.
-    }
-    return 'unknown';
-}
+/** The running version; see `config/version.ts`. */
+const ownVersion = botVersion;
 const program = new Command();
 program
     .name('cop')
@@ -213,7 +195,7 @@ program
         replyTimeoutMs: 60_000,
         signInTimeoutMs: 15 * 60_000,
         humanWaitMs: 15 * 60_000,
-        onEvent: (e, d) => process.stdout.write(`  ${e}${d && Object.keys(d).length ? ' ' + JSON.stringify(d) : ''}
+        onEvent: (e, d) => process.stdout.write(`  ${e}${d && Object.keys(d).length ? ' ' + JSON.stringify(d) : ''}
 `),
     });
     await transport.open();
@@ -506,14 +488,14 @@ program
     console.log('');
     console.log(`task "${done?.title}": ${done?.status} after ${done?.iterations ?? 0} iteration(s)`);
     if (done?.summary)
-        console.log(`
-Summary:
+        console.log(`
+Summary:
 ${done.summary}`);
     if (done?.reason)
-        console.log(`
+        console.log(`
 Reason: ${done.reason}`);
     if (final?.chat)
-        console.log(`
+        console.log(`
 chat: ${final.chat.name} — ${final.chat.url}`);
     if (done?.runId)
         console.log(`log: ${join(cfg.resolved.runsDir, done.runId, 'task-log.txt')}`);
@@ -533,8 +515,8 @@ program
         return;
     }
     const c = withChat.chat;
-    console.log(`${c.name}
-${c.url}
+    console.log(`${c.name}
+${c.url}
 session ${withChat.id}, ${withChat.tasks.length} task(s), created ${c.createdAt}`);
 });
 program.parseAsync(process.argv).catch((e) => {

package/dist/src/config/version.js

@@ -0,0 +1,30 @@
+/**
+ * The version of the copilot-operator that is running, from its own package.json.
+ *
+ * It was a literal, '0.1.0', and stayed that through thirteen releases, so a bug report's
+ * `cop --version` named a version that never had the bug. Read where the code is — `src/` under
+ * tsx, `dist/src/` in a clone, `node_modules/copilot-operator/dist/src/` once installed — so it
+ * cannot drift from what npm installed. botRootDir() falls back to the working directory when it
+ * finds no package.json of ours, and that one is the user's project's: its version is not ours to
+ * print, so the name is checked and anything else says "unknown".
+ *
+ * Written into every export and attempt record too: a report sent as a screenshot from another
+ * machine could not say which version made it, and the operator had to be asked.
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { botRootDir } from '../exec/workDir.js';
+let cached;
+export function botVersion() {
+    if (cached)
+        return cached;
+    try {
+        const pkg = JSON.parse(readFileSync(join(botRootDir(), 'package.json'), 'utf8'));
+        if (pkg.name === 'copilot-operator' && typeof pkg.version === 'string' && pkg.version)
+            return (cached = pkg.version);
+    }
+    catch {
+        // No readable package.json: say so rather than guess.
+    }
+    return 'unknown';
+}

package/dist/src/orchestrator/taskRunner.js

@@ -45,9 +45,9 @@ import { composeHandoff } from '../session/handoff.js';
 import { ProgressWatch } from './progress.js';
 import { contractConflicts, readsTreeClean } from './contract.js';
 import { treeFingerprint } from '../vcs/git.js';
-import { prepareForTask, commitTaskResult, repoDirOf, trackedRepoOf } from '../vcs/taskVcs.js';
-import { protectInputs, inputsMessage } from '../vcs/inputs.js';
-import { artifactPatterns, keepArtifacts } from '../vcs/artifacts.js';
+import { prepareForTask, commitTaskResult, commitShortfall, repoDirOf, trackedRepoOf } from '../vcs/taskVcs.js';
+import { protectInputs, inputsMessage, inputsAtCommit, untrackedInputs } from '../vcs/inputs.js';
+import { artifactPatterns, artifactState, keepArtifacts } from '../vcs/artifacts.js';
 import { exportMachine, writeAttemptRecord } from '../session/exports.js';
 /** Why a task that was reported as done is being closed as failed. */
 function checksFailedReason(outcomes) {
@@ -582,12 +582,14 @@ export async function runTask(transport, session, task, deps) {
     };
     /** The session's read-only input files and the commit they are put back from, once the task is on its own branch. */
     let inputsGuard = null;
+    /** The artifact files as they were when the task started; what is kept afterwards is what changed. */
+    let artifactsBefore;
     /** Puts back whatever a round did to the input files, and tells the chat and the record. */
     const guardInputs = async (iteration) => {
         if (!inputsGuard)
             return null;
         const guard = inputsGuard;
-        const check = await protectInputs(repoDirOf(session), guard.base, guard.inputs).catch((e) => ({
+        const check = await protectInputs(repoDirOf(session), guard.base, guard.inputs, guard.keep).catch((e) => ({
             changed: ['(the input files)'],
             restored: [],
             failed: [{ path: '(the input files)', why: e.message }],
@@ -617,6 +619,10 @@ export async function runTask(transport, session, task, deps) {
                 status = 'failed';
                 reason = `the operator's input file(s) ${check.failed.map((f) => f.path).join(', ')} were changed and could not be put back as they were: ${check.failed.map((f) => f.why).join('; ')}.`;
             }
+            // Said on the record either way: the inputs as the task leaves them, against their recorded sums.
+            if (check && check.failed.length === 0) {
+                sink.event('inputs-verified', { files: inputsGuard.inputs.files.length }, `${inputsGuard.inputs.files.length} input file(s) are as the session's start recorded them: same sums`);
+            }
         }
         /*
          * The session's artifacts, whatever the outcome: copied into this attempt's record, so the
@@ -624,9 +630,14 @@ export async function runTask(transport, session, task, deps) {
          */
         const patterns = artifactPatterns(session.vcs);
         const projectRoot = repoDirOf(session) || session.projectDir?.trim() || '';
-        if (patterns.length > 0 && projectRoot) {
-            const kept = await keepArtifacts(projectRoot, patterns, join(artifactsDir, 'project')).catch((e) => ({ kept: [], skipped: [`(all: ${e.message})`] }));
-            sink.event('artifacts-kept', { kept: kept.kept.length, skipped: kept.skipped }, `artifacts kept with the run: ${kept.kept.length} file(s)${kept.skipped.length > 0 ? `; not kept: ${kept.skipped.slice(0, 5).join('; ')}` : ''}`, kept.skipped.length > 0 ? 'warn' : 'info');
+        if ((patterns.length > 0 || (task.outputs?.length ?? 0) > 0) && projectRoot) {
+            // Only what this task made or changed, inside its scope, or declared as its outputs.
+            const kept = await keepArtifacts(projectRoot, patterns, join(artifactsDir, 'project'), { before: artifactsBefore, scope: task.scope, outputs: task.outputs })
+                .catch((e) => ({ kept: [], skipped: [`(all: ${e.message})`], unchanged: 0, outsideScope: [] }));
+            sink.event('artifacts-kept', { kept: kept.kept.length, skipped: kept.skipped, unchanged: kept.unchanged, outsideScope: kept.outsideScope.slice(0, 20) }, `artifacts kept with the run: ${kept.kept.length} file(s) this task made or changed` +
+                `${kept.unchanged > 0 ? `; ${kept.unchanged} already there and untouched, not kept` : ''}` +
+                `${kept.outsideScope.length > 0 ? `; ${kept.outsideScope.length} outside the task's scope, not kept` : ''}` +
+                `${kept.skipped.length > 0 ? `; not kept: ${kept.skipped.slice(0, 5).join('; ')}` : ''}`, kept.skipped.length > 0 ? 'warn' : 'info');
             await setTask((t) => {
                 t.artifactsKept = kept.kept.length > 0 ? kept.kept : undefined;
             });
@@ -654,10 +665,26 @@ export async function runTask(transport, session, task, deps) {
         // The task is re-read first, because the branch was recorded on it after this closure
         // was created.
         const fresh = (await store.getSession(session.id))?.tasks.find((x) => x.id === task.id);
+        let vcsError;
         const vcsAfter = await commitTaskResult(session, { ...task, vcs: fresh?.vcs }, { status, summary, reason, deviations }, bus).catch((e) => {
+            vcsError = e.message;
             sink.event('vcs-error', { error: String(e) }, `version control failed after the task: ${e.message}`, 'warn');
             return undefined;
         });
+        /*
+         * With version control on, a task is done only when its work is committed. The commit used to
+         * fail — on the branch it was moved off, on a git error, on uncommitted files left behind — and
+         * the task still ended done, its work loose in the tree and the next task refusing to start over
+         * it. Now it ends failed with why; the work stays in the working tree, nothing is lost.
+         */
+        if (status === 'done') {
+            const uncommitted = await commitShortfall(session, fresh?.vcs ?? task.vcs, vcsAfter, vcsError);
+            if (uncommitted) {
+                status = 'failed';
+                reason = uncommitted;
+                sink.event('commit-failed', { problem: vcsAfter?.problem ?? vcsError, uncommitted: vcsAfter?.afterCommit?.changed?.slice(0, 20) }, uncommitted, 'error');
+            }
+        }
         /*
          * The checks about a clean tree, now that the runner has committed. A done task whose tree is
          * still not clean after the commit has failed; any other ending keeps its own reason, and the
@@ -912,8 +939,23 @@ export async function runTask(transport, session, task, deps) {
         // The operator's input files, read-only on a branch of the task's own; see `vcs/inputs.ts`.
         const startNow = (await store.getSession(session.id))?.vcsStart;
         if (onOwnBranch && startNow?.inputs?.readOnly && startNow.inputs.files.length > 0) {
-            inputsGuard = { base: prepared.vcs.baseCommit, inputs: startNow.inputs };
+            /*
+             * Held to the inputs as this task's own starting commit has them, not the session's record: a
+             * re-run is cut from where the task first started, before any inputs changed since. And what is
+             * under the patterns untracked now is the operator's, never removed by the guard.
+             */
+            const baseCommit = prepared.vcs.baseCommit;
+            inputsGuard = {
+                base: baseCommit,
+                inputs: await inputsAtCommit(repoDirOf(session), baseCommit, startNow.inputs),
+                keep: await untrackedInputs(repoDirOf(session), startNow.inputs.patterns),
+            };
         }
+        // Before the first step: what is under the artifact patterns now is not this task's evidence.
+        const artifactRoot = repoDirOf(session) || session.projectDir?.trim() || '';
+        const artifactPatternsNow = [...artifactPatterns(session.vcs), ...(task.outputs ?? [])];
+        if (artifactRoot && artifactPatternsNow.length > 0)
+            artifactsBefore = await artifactState(artifactRoot, artifactPatternsNow).catch(() => undefined);
         /** The working tree's fingerprint, when the task is on a branch of its own; null otherwise. */
         const treeNow = async () => prepared.vcs.branch && !prepared.vcs.problem && prepared.vcs.baseCommit ? await treeFingerprint(repoDirOf(session)).catch(() => null) : null;
         /*
@@ -1004,7 +1046,12 @@ export async function runTask(transport, session, task, deps) {
             workDirNote: workingDirNote(work),
             vcsNote: prepared.note,
             readOnlyNote: task.readOnly ? READ_ONLY_NOTE : undefined,
-            scopeNote: scopeNote(scope, scopeEnforced),
+            scopeNote: [
+                scopeNote(scope, scopeEnforced),
+                (task.outputs?.length ?? 0) > 0
+                    ? `## Outputs\n\nThis task is to produce: ${(task.outputs ?? []).map((o) => `\`${o}\``).join(', ')}. What it creates or changes there is kept with the run's record as its evidence.`
+                    : '',
+            ].filter(Boolean).join('\n\n'),
             approachesNote: minApproaches > MIN_TRIED_APPROACHES
                 ? `## Giving up\n\nThis task may end with status "blocked" only after at least ${minApproaches} genuinely different approaches, ` +
                     `each listed in "tried". With fewer, the runner asks you for another approach instead of accepting it.`

package/dist/src/plan/brief.js

@@ -324,6 +324,7 @@ const FIELD_ROWS_EN = [
     ['review', 'task', 'no', 'Set to `false` to skip the review for one task. Absent means the session decides.'],
     ['readOnly', 'task', 'no', '`true` for a task that must not change files — an audit, a smoke test, a report. The runner fails it if the tree changed, and still commits the change on its branch so nothing is lost.'],
     ['scope', 'task', 'no', 'The paths the task may change: files, folders (`tests/e2e/`) or `*`/`**` patterns. With version control on, the runner puts back any change outside them. Give it when the task is about one suite or module.'],
+    ['outputs', 'task', 'no', 'Evidence the task is to produce (a report, an archive): patterns. What it creates or changes there is kept with the run\'s record.'],
     ['tasks', 'session', 'yes', 'At least one, in the order they must run.'],
     ['title', 'task', 'yes', '3 to 120 characters. Short, latin, hyphenated.'],
     ['prompt', 'task', 'yes', 'The task itself, at least 30 characters. This is what Copilot reads.'],
@@ -394,6 +395,7 @@ const FIELD_ROWS_BG = [
     ['review', 'задача', 'не', 'Сложи `false`, за да се пропусне рецензията само за тази задача. Липсата значи каквото казва сесията.'],
     ['readOnly', 'задача', 'не', '`true` за задача, която не бива да променя файлове — одит, smoke тест, доклад. Runner-ът я проваля, ако дървото е променено, и пак комитва промяната на клона ѝ, за да не се губи нищо.'],
     ['scope', 'задача', 'не', 'Пътищата, които задачата може да променя: файлове, папки (`tests/e2e/`) или шаблони с `*`/`**`. При включен контрол на версиите runner-ът връща всяка промяна извън тях. Давай го, когато задачата е за един suite или модул.'],
+    ['outputs', 'задача', 'не', 'Доказателства, които задачата трябва да създаде (отчет, архив): шаблони. Каквото създаде или промени там, се пази към записа на пускането.'],
     ['tasks', 'сесия', 'да', 'Поне една, в реда, в който трябва да се изпълнят.'],
     ['title', 'задача', 'да', 'От 3 до 120 знака. Кратко, латиница, с тирета.'],
     ['prompt', 'задача', 'да', 'Самата задача, поне 30 знака. Това чете Copilot.'],
@@ -461,8 +463,8 @@ its own, and the session starts from it; the user approves the exact list on the
 \`"tracked-only-snapshot"\` takes tracked changes only. Secrets (\`.env\`), tool output and files outside
 the project are never taken, and an ignored file only when a task's \`scope\` names it. The snapshot is
 taken where the changes are, so use it with \`startFrom\` \`"branch"\` only when the repository is already on
-that branch, and never with \`"existing-branch"\`. Leaving it out keeps \`"reject"\`: version control stays out
-of a tree with uncommitted changes.
+that branch, and never with \`"existing-branch"\`. Leaving it out keeps \`"reject"\`: a tree with uncommitted
+changes refuses the task, and nothing runs.
 
 **userInputs** — files the user provides for the work (schemas, test data):
 \`{ "paths": ["rules-engine/test-data/schemas/*.yaml"] }\`. They go into the commit every session starts from —
@@ -471,11 +473,14 @@ gets them committed on top of it — and they are read-only while the tasks run
 the user wants the work to change them). Ask the user which files are inputs; never name a whole folder of
 work, and never \`.env\`. **artifacts** — evidence the work writes (reports, ZIP archives, test results):
 \`{ "paths": ["rules-engine/test-results/**"] }\`. Never committed, kept with the run; tell tasks to write
-evidence there instead of changing \`.gitignore\`.
+evidence there instead of changing \`.gitignore\`. Only what a task creates or changes there is kept, and an
+artifacts pattern must never cover the input files or a task's work ("rules-engine/**" would hide both): name
+the evidence folders only.
 
 A session with \`"startFrom": "previous-session"\` continues the whole work of the one before it only when
 that one is \`"branchMode": "per-session"\`: per task, its work is on several branches and the next session
-refuses to start from part of it.
+refuses to start from part of it. It also refuses when the session before has not finished (a task failed or
+blocked): finish it first.
 
 Put the same \`startFrom\` on every session that works in one repository unless the user wants it
 mixed. Leaving it out keeps the old behaviour — whatever branch the repository is on — which is
@@ -542,8 +547,8 @@ run“, на отделен клон, и сесията тръгва от нег
 сесията. \`"tracked-only-snapshot"\` взема само tracked промени. Тайни (\`.env\`), изход от инструменти и
 файлове извън проекта никога не се вземат, а ignored файл — само когато \`scope\` на задача го посочва.
 Снимката се прави там, където са промените, затова с \`startFrom\` \`"branch"\` само ако хранилището вече е на
-този клон, и никога с \`"existing-branch"\`. Ако го пропуснеш, остава \`"reject"\`: контролът на версиите
-не влиза в дърво с некомитнати промени.
+този клон, и никога с \`"existing-branch"\`. Ако го пропуснеш, остава \`"reject"\`: дърво с некомитнати
+промени отказва задачата и нищо не се изпълнява.
 
 **userInputs** — файлове, които потребителят дава за работата (схеми, тестови данни):
 \`{ "paths": ["rules-engine/test-data/schemas/*.yaml"] }\`. Влизат в комита, от който тръгва всяка сесия —
@@ -552,11 +557,14 @@ run“, на отделен клон, и сесията тръгва от нег
 потребителят иска работата да ги променя). Питай кои файлове са вход; никога цяла папка с работа и никога
 \`.env\`. **artifacts** — доказателства, които работата пише (отчети, ZIP архиви, резултати от тестове):
 \`{ "paths": ["rules-engine/test-results/**"] }\`. Никога не се комитват, пазят се към пускането; кажи на
-задачите да пишат доказателствата там, вместо да променят \`.gitignore\`.
+задачите да пишат доказателствата там, вместо да променят \`.gitignore\`. Пази се само каквото задачата създаде
+или промени там, и шаблон за artifacts никога не покрива входните файлове или работата на задача
+("rules-engine/**" би скрил и двете): посочвай само папките с доказателства.
 
 Сесия с \`"startFrom": "previous-session"\` продължава цялата работа на предната само ако тя е
 \`"branchMode": "per-session"\`: при per-task работата ѝ е на няколко клона и следващата сесия отказва да
-тръгне от част от нея.
+тръгне от част от нея. Отказва и когато предната сесия не е завършила (задача е провалена или блокирана):
+първо я завърши.
 
 Сложи един и същ \`startFrom\` на всички сесии в едно хранилище, освен ако потребителят не иска
 различни. Ако го пропуснеш, остава старото поведение — от който клон е хранилището в момента —

package/dist/src/plan/importPlan.js

@@ -1,5 +1,6 @@
 import { DEFAULT_VCS, applyDefaultProject } from '../session/store.js';
 import { normalisePatterns } from '../vcs/inputs.js';
+import { coveredByArtifacts } from '../vcs/artifacts.js';
 import { availableShells, detectShells } from '../exec/shells.js';
 /** The heading under which a task's acceptance bar reaches Copilot. English, like level 1. */
 const EXPECTED_HEADER = '### Expected result';
@@ -183,6 +184,18 @@ defaultProjectDir = '') {
         }
         lastIn.set(repo, { name: planned.name, perTask: (planned.vcs.branchMode ?? 'per-task') === 'per-task', tasks: planned.tasks.length });
     }
+    // A task whose whole scope is under the artifact patterns would have its work kept out of git.
+    for (const planned of plan.sessions) {
+        const arts = planned.vcs?.artifacts?.paths ?? [];
+        if (!planned.vcs?.enabled || arts.length === 0)
+            continue;
+        for (const task of planned.tasks) {
+            if (task.scope.length > 0 && coveredByArtifacts(task.scope, arts).length === task.scope.length) {
+                warnings.push(`Task "${task.title}" in session "${planned.name}" may change only ${task.scope.join(', ')}, and the session's artifacts patterns cover all of it: ` +
+                    'whatever it writes is kept with the run and never committed. If that work is meant to be committed, narrow "artifacts".');
+            }
+        }
+    }
     for (const planned of plan.sessions) {
         // Attaching project files to the chat was removed; an old plan's root is still its project folder.
         if (planned.mirror?.enabled) {
@@ -238,6 +251,7 @@ defaultProjectDir = '') {
                 reviewEnabled: task.review,
                 readOnly: task.readOnly || undefined,
                 scope: task.scope.length > 0 ? task.scope : undefined,
+                outputs: task.outputs.length > 0 ? task.outputs : undefined,
             });
             titles.push(added.title);
         }

package/dist/src/plan/schema.js

@@ -14,6 +14,7 @@
  */
 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.
@@ -140,6 +141,15 @@ const VcsInput = z
     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',
@@ -297,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',
@@ -3241,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/session/exports.js

@@ -22,6 +22,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 { botVersion } from '../config/version.js';
 import { withoutPersona } from '../plan/importPlan.js';
 const EXPECTED_HEADER = '### Expected result';
 const GOAL_HEADER = '## Goal of this session';
@@ -171,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;
@@ -451,6 +454,8 @@ async function domainTask(session, task, runsDir) {
         session: {
             id: session.id,
             name: session.name,
+            // The commit the session's tasks are cut from, by the name a report looks for.
+            ...(session.vcsBaseCommit ? { baselineCommit: session.vcsBaseCommit } : {}),
             ...(session.vcsStart
                 ? {
                     start: {
@@ -578,6 +583,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,
@@ -649,6 +656,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,
@@ -680,6 +689,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/store.js

@@ -76,6 +76,7 @@ export const TASK_FIELD_ON_RERUN = {
     reviewEnabled: 'kept',
     readOnly: 'kept',
     scope: 'kept',
+    outputs: 'kept',
     // What one review noticed is arithmetic for every attempt after it.
     reviewChecks: 'kept',
     attempts: 'kept',
@@ -468,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);

package/dist/src/vcs/artifacts.js

@@ -22,6 +22,21 @@ import { looksGenerated } from './commitHygiene.js';
 import { git } from './git.js';
 import { normalisePatterns } from './inputs.js';
 import { inScope } from './scope.js';
+/**
+ * The patterns among `patterns` whose files an artifact pattern would cover, and so keep out of git.
+ * Judged by a path the pattern stands for (`**` and `*` filled in). Found in a run on 0.1.18: an
+ * artifact pattern of a whole project folder covered the input files and the task's own work, every
+ * file the task wrote was ignored, and "nothing to commit" ended it done.
+ */
+export function coveredByArtifacts(patterns, artifacts) {
+    const arts = normalisePatterns(artifacts);
+    if (arts.length === 0)
+        return [];
+    return normalisePatterns(patterns).filter((p) => {
+        const sample = p.replace(/\/+$/, '/f').replace(/\*\*/g, 'a/b').replace(/[*?]/g, 'x');
+        return inScope(sample, arts);
+    });
+}
 /** The session's artifact patterns, without ones that name the whole project. */
 export function artifactPatterns(vcs) {
     return normalisePatterns(vcs?.artifacts?.paths ?? []);
@@ -59,7 +74,23 @@ export async function excludeArtifacts(dir, session) {
     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 };
+const LIMITS = { files: 1000, fileBytes: 100 * 1024 * 1024, totalBytes: 500 * 1024 * 1024, listed: 20_000 };
+/**
+ * The artifact files as they are before a task, so that what is kept afterwards is what the task
+ * made or changed. Found in a real run: a broad pattern kept every file already under it, evidence
+ * of earlier sessions included, as if this task had produced it.
+ */
+export async function artifactState(root, patterns) {
+    const state = new Map();
+    if (patterns.length === 0 || !root)
+        return state;
+    for (const rel of await matching(root, patterns)) {
+        const info = await stat(join(root, rel)).catch(() => null);
+        if (info)
+            state.set(rel, `${info.size}:${info.mtimeMs}`);
+    }
+    return state;
+}
 /** Files under `root` matching the patterns, found on disk: git's view does not matter for evidence. */
 async function matching(root, patterns) {
     const out = [];
@@ -73,7 +104,7 @@ async function matching(root, patterns) {
         return fixed.join('/');
     }));
     const walk = async (rel) => {
-        if (out.length > LIMITS.files * 2)
+        if (out.length > LIMITS.listed)
             return;
         const abs = join(root, rel);
         const info = await stat(abs).catch(() => null);
@@ -97,17 +128,25 @@ async function matching(root, patterns) {
     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.
+ * Copies into the attempt's record, `<dest>/<path>`, the artifact files this task made or changed:
+ * under the session's artifact patterns or the task's own `outputs`, new or changed since `before`
+ * (`artifactState` at the task's start), and inside the task's scope when it has one (its outputs
+ * always count). A file already there and untouched is not this task's evidence and is not kept.
+ * Secrets are never copied; past the limits the rest is skipped and said.
  */
-export async function keepArtifacts(root, patterns, dest) {
+export async function keepArtifacts(root, patterns, dest, opts = {}) {
     const kept = [];
     const skipped = [];
-    if (patterns.length === 0 || !root)
-        return { kept, skipped };
+    const outsideScope = [];
+    let unchanged = 0;
+    const outputs = normalisePatterns(opts.outputs ?? []);
+    const scope = opts.scope ?? [];
+    const all = [...new Set([...patterns, ...outputs])];
+    if (all.length === 0 || !root)
+        return { kept, skipped, unchanged, outsideScope };
     let total = 0;
     const base = resolve(root);
-    for (const rel of await matching(root, patterns)) {
+    for (const rel of await matching(root, all)) {
         const from = resolve(join(root, rel));
         if (!from.startsWith(base + sep))
             continue;
@@ -118,6 +157,14 @@ export async function keepArtifacts(root, patterns, dest) {
         const info = await stat(from).catch(() => null);
         if (!info)
             continue;
+        if (opts.before && opts.before.get(rel) === `${info.size}:${info.mtimeMs}`) {
+            unchanged += 1;
+            continue;
+        }
+        if (scope.length > 0 && !inScope(rel, scope) && !(outputs.length > 0 && inScope(rel, outputs))) {
+            outsideScope.push(rel);
+            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;
@@ -134,5 +181,5 @@ export async function keepArtifacts(root, patterns, dest) {
             skipped.push(`${rel} (${e.message})`);
         }
     }
-    return { kept, skipped };
+    return { kept, skipped, unchanged, outsideScope };
 }