copilot-operator 0.1.2 → 0.1.4

package/dist/src/exec/policy.js

@@ -92,7 +92,7 @@ confinement) {
     // The allowlist after the known-bad floor and the operator's deny list, so their precise
     // messages win, and this catches the long tail neither of them was ever going to enumerate: a
     // program that is simply not part of this project's toolchain. See `programs.ts`.
-    const offlist = programRefusal(command, allowedPrograms);
+    const offlist = programRefusal(command, allowedPrograms, shell);
     if (offlist)
         return offlist;
     const trap = findShellExecuteTrap(command, shell, env);

package/dist/src/exec/policyManifest.js

@@ -31,7 +31,21 @@ export function digestOf(values) {
     const canonical = JSON.stringify([...values].map((v) => v.trim()).filter(Boolean).sort());
     return createHash('sha256').update(canonical).digest('hex').slice(0, 12);
 }
-export const NETWORK_FETCH = "a command that fetches from the network (Invoke-WebRequest, Invoke-RestMethod, curl, wget, Start-BitsTransfer, .NET web clients, ftp/scp) is held for the operator in every mode; with nobody to ask it is refused. Requests to localhost and the project's package managers are not held";
+const FETCHES = 'a command that fetches from the network (Invoke-WebRequest, Invoke-RestMethod, curl, wget, Start-BitsTransfer, .NET web clients, ftp/scp)';
+const NOT_HELD = "Requests to localhost and the project's package managers are not held";
+/**
+ * The manifest's sentence about downloads, for this mode and the operator's choice. A step-by-step
+ * run shows every step to a person, so the choice changes nothing there and is not mentioned.
+ */
+export function networkFetchStatement(mode, choice = 'ask') {
+    if (mode === 'confirm')
+        return `${FETCHES} is shown to the operator with a note that it downloads, like every step of this run. ${NOT_HELD}`;
+    if (choice === 'refuse')
+        return `${FETCHES} is refused back to the chat without running (execution.networkFetch: refuse). ${NOT_HELD}`;
+    if (choice === 'run')
+        return `${FETCHES} RUNS WITHOUT ANYONE READING IT — the operator chose this (execution.networkFetch: run). Only the deny list and the built-in refusals applied`;
+    return `${FETCHES} is held for the operator even in this unattended run (execution.networkFetch: ask); with nobody to ask it is refused. ${NOT_HELD}`;
+}
 export function collectPolicyManifest(input, env = process.env) {
     const names = DANGEROUS_TECHNIQUES.map((t) => t.name);
     return {
@@ -46,7 +60,7 @@ export function collectPolicyManifest(input, env = process.env) {
             programs: [...input.allowedPrograms],
         },
         chatFiles: 'the chat cannot supply a file: this runner has no file step and executes nothing it did not receive as a command',
-        networkFetch: NETWORK_FETCH,
+        networkFetch: networkFetchStatement(input.mode, input.networkFetch),
         denyPatterns: { count: input.denyPatterns.length, digest: digestOf(input.denyPatterns) },
         builtIn: { count: names.length, digest: digestOf(names), names },
         lock: input.lock ?? { applied: false, changes: [] },

package/dist/src/exec/programs.js

@@ -29,6 +29,7 @@
  * before this existed starts failing on an upgrade.
  */
 import { extname } from 'node:path';
+import { scanCommandHeads } from './commandHeads.js';
 /**
  * Windows executable extensions. A token carrying one of these names a program by file, whatever
  * the stem, so it is always checked; a token with any other extension (`config.json`, `app.ts`)
@@ -55,6 +56,7 @@ const SHELL_WORDS = new Set([
     'gi', 'gp', 'sp', 'si', 'gm', 'gu', 'gv', 'sv', 'select', 'where', 'foreach-object', 'where-object',
     'sort', 'group', 'measure', 'ft', 'fl', 'fw', 'fh', 'oh', 'out-host', 'tee',
     'sls', 'gcm', 'gmo', 'ipmo', 'man', 'help', 'more', 'h', 'history', 'r',
+    '%', '?', // ForEach-Object and Where-Object, as `ls | % { $_.Name }` writes them
     'gsv', 'gps', 'ps', 'kill', 'sleep', 'start', 'saps', 'spps', 'sasv', 'spsv',
     'iwr', 'irm', 'wget', 'curl', // PowerShell aliases for Invoke-WebRequest/Invoke-RestMethod; the raw .exe forms are allowlisted by name if wanted, and iwr|iex is caught by dangerous.ts
     // cmd built-ins
@@ -62,87 +64,13 @@ const SHELL_WORDS = new Set([
     'pushd', 'popd', 'ver', 'vol', 'date', 'time', 'exist', 'not', 'defined', 'errorlevel',
 ]);
 /**
- * The heads of every statement in a command line: the first token after the start and after each
- * separator that begins a new command (`|`, `;`, `&`, `&&`, `||`, a newline, a `(` sub-expression
- * or a `{` script block). Quote- and depth-aware so a separator inside `'...'`, `"..."` or an
- * argument list does not split a statement, and a back-tick before a newline continues it.
- *
- * Best effort by design. The point is to find the programs a line would obviously start, not to
- * be a PowerShell parser; a construction it cannot read yields no head for that fragment, and the
- * fragment then rests on `dangerous.ts` and the human, which is where the honest limit was always
- * going to be anyway.
+ * The name at the head of every command a line invokes. Read by `commandHeads.ts`, which follows
+ * PowerShell's command and expression modes (or `cmd`'s rules for a `cmd` step), so strings,
+ * operators, array values, method arguments and hashtable keys are not mistaken for programs, and
+ * a command nested in a script block, a subexpression or after an assignment is not missed.
  */
-export function commandHeads(command) {
-    const heads = [];
-    const boundaries = new Set(['|', ';', '&', '\n', '(', '{']);
-    let expectStart = true;
-    let quote = null;
-    let i = 0;
-    const readToken = (from) => {
-        let j = from;
-        let text = '';
-        let q = null;
-        while (j < command.length) {
-            const ch = command[j];
-            if (q) {
-                if (ch === q)
-                    q = null;
-                else
-                    text += ch;
-                j += 1;
-                continue;
-            }
-            if (ch === "'" || ch === '"') {
-                q = ch;
-                j += 1;
-                continue;
-            }
-            if (/\s/.test(ch) || boundaries.has(ch) || ch === ')' || ch === '}')
-                break;
-            text += ch;
-            j += 1;
-        }
-        return { text, end: j };
-    };
-    while (i < command.length) {
-        const ch = command[i];
-        if (quote) {
-            if (ch === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (ch === "'" || ch === '"') {
-            quote = ch;
-            i += 1;
-            continue;
-        }
-        if (expectStart && !/\s/.test(ch) && !boundaries.has(ch) && ch !== ')' && ch !== '}') {
-            const { text, end } = readToken(i);
-            i = end;
-            // A dot-source — `. .\script.ps1` — runs the file that follows in the current scope. The
-            // dot is not what runs; the next token is, and it is the one the allowlist has to see.
-            // (`& .\script.ps1` already works this way because `&` is a boundary.)
-            if (text === '.')
-                continue;
-            if (text)
-                heads.push(text);
-            expectStart = false;
-            continue;
-        }
-        if (boundaries.has(ch)) {
-            // A back-tick immediately before a newline is a line continuation, not a new statement.
-            if (ch === '\n' && command[i - 1] === '`') {
-                i += 1;
-                continue;
-            }
-            expectStart = true;
-            i += 1;
-            continue;
-        }
-        i += 1;
-    }
-    return heads;
+export function commandHeads(command, shell) {
+    return scanCommandHeads(command, shell).heads;
 }
 /**
  * The external-program name a statement head invokes, normalised for the allowlist, or null when
@@ -273,12 +201,24 @@ export function inlineCodeRefusal(command) {
  * is a legitimate tool this project happens to need, and the fix is one line of config — not a
  * reason to weaken the gate for everyone.
  */
-export function programRefusal(command, allowedPrograms) {
+export function programRefusal(command, allowedPrograms, shell = 'pwsh') {
     if (!allowedPrograms || allowedPrograms.length === 0)
         return null;
     const allowed = new Set(allowedPrograms.map((p) => p.trim().toLowerCase().replace(/\.(exe|com|bat|cmd|ps1|msi)$/i, '')).filter(Boolean));
+    /*
+     * Fail-closed: a line that cannot be read with certainty is a line whose programs are not known,
+     * and an allowlist that cannot name the programs has nothing to check them against. What makes
+     * a line uncertain — an unclosed string or bracket, a program chosen through a variable — is
+     * never needed by honest work, so refusing it costs a rewrite and guessing could cost the gate.
+     */
+    const scan = scanCommandHeads(command, shell);
+    if (scan.uncertain) {
+        return (`refused: the runner could not tell which programs this line starts (${scan.uncertain}). ` +
+            'Write it so every program is named literally — close each quote and bracket, and call a program by its ' +
+            'name or a literal path rather than through a variable or an expression.');
+    }
     // What `Start-Process` is asked to start is a program this line starts, as much as a head is.
-    for (const head of [...commandHeads(command), ...startProcessTargets(command)]) {
+    for (const head of [...scan.heads, ...startProcessTargets(command)]) {
         const program = externalProgram(head);
         if (program && !allowed.has(program)) {
             return (`refused: "${program}" is not in execution.allowedPrograms. This machine runs only the project's ` +

package/dist/src/exec/reportFile.js

@@ -42,8 +42,11 @@ export function clip(text, maxChars) {
     return `${text.slice(0, half)}\n\n[... ${dropped} characters omitted ...]\n\n${text.slice(-half)}`;
 }
 function sectionFor(r, maxOutputChars) {
-    const head = `--- step ${r.id} (${r.shell}, ${r.outcome}, exit ${r.exitCode}, ` +
-        `${(r.durationMs / 1000).toFixed(1)}s)\n$ ${r.command}\n`;
+    // A refused step never ran, so it is not given an exit code or a duration that could be read as
+    // a command that ran and failed; the header says what happened instead.
+    const head = r.outcome === 'refused'
+        ? `--- step ${r.id} (${r.shell}, REFUSED by the runner, never executed, no exit code)\n$ ${r.command}\n`
+        : `--- step ${r.id} (${r.shell}, ${r.outcome}, exit ${r.exitCode}, ` + `${(r.durationMs / 1000).toFixed(1)}s)\n$ ${r.command}\n`;
     const out = clip(r.stdout, maxOutputChars);
     const err = r.stderr.trim().length > 0 ? `[stderr]\n${clip(r.stderr, maxOutputChars)}\n` : '';
     const note = r.truncated ? `[note] output was truncated; the full stream is in ${r.logPath}\n` : '';

package/dist/src/orchestrator/review.js

@@ -426,7 +426,7 @@ ${machineNote}` : contract);
                     confinement: { roots: deps.roots, cwd: deps.cwd },
                 });
                 if (decision.action !== 'run') {
-                    results.push(refused(step.id, decision.reason, step.cmd, step.shell));
+                    results.push(refused(step.id, decision.reason, step.cmd, step.shell, decision.by === 'operator' ? 'operator' : 'runner'));
                     if (decision.action === 'abort')
                         break;
                     continue;
@@ -525,7 +525,7 @@ export function refusedChecksMessage(refused) {
     ].join('\n');
 }
 /** A step the review did not run, in the shape the reporter expects. */
-function refused(id, reason, command = '(not run)', requested) {
+function refused(id, reason, command = '(not run)', requested, by = 'runner') {
     return {
         id,
         // The shell it would have run in, rather than the one this file used to name: a report line
@@ -537,7 +537,8 @@ function refused(id, reason, command = '(not run)', requested) {
         requestedShell: requested ?? null,
         command,
         exitCode: -4,
-        outcome: 'aborted',
+        // Who declined it, as in `refusedResult` in the task runner: a rule, or a person.
+        outcome: by === 'operator' ? 'aborted' : 'refused',
         durationMs: 0,
         stdout: '',
         stderr: `[policy] step not executed: ${reason}\n`,

package/dist/src/orchestrator/taskRunner.js

@@ -41,6 +41,7 @@ import { composeOpening, READ_ONLY_NOTE } from '../session/compose.js';
 import { mirrorProject, describeMirror } from '../context/projectMirror.js';
 import { projectNameFor, projectTargetDir, removeLegacyFlatMirror } from '../context/desktopMirror.js';
 import { prepareForTask, commitTaskResult, repoDirOf } from '../vcs/taskVcs.js';
+import { exportMachine, writeAttemptRecord } from '../session/exports.js';
 /** Why a task that was reported as done is being closed as failed. */
 function checksFailedReason(outcomes) {
     const failed = outcomes.filter((o) => !o.passed);
@@ -110,14 +111,18 @@ function blockedReason(tried, needed) {
         .filter(Boolean)
         .join(' — ');
 }
-/** A step that was refused never reaches the shell, but Copilot still has to hear about it. */
-function refusedResult(step, reason) {
+/**
+ * A step that was not run never reaches the shell, but Copilot still has to hear about it — and
+ * hear who declined it: the runner (`refused`: a rule, so rewrite the step) or the operator
+ * (`aborted`: a person stopped or skipped it).
+ */
+function refusedResult(step, reason, by = 'runner') {
     return {
         id: step.id,
         shell: effectiveShell(step.shell),
         command: describeStep(step),
         exitCode: -4,
-        outcome: 'aborted',
+        outcome: by === 'operator' ? 'aborted' : 'refused',
         durationMs: 0,
         stdout: '',
         stderr: `[policy] step not executed: ${reason}\n`,
@@ -445,6 +450,26 @@ export async function runTask(transport, session, task, deps) {
         });
         sink.event('task-finished', { status, reason, iterations }, `task "${task.title}" ${status}${reason ? `: ${reason}` : ''}`);
         await log.close();
+        /*
+         * An attempt that did not end done leaves its plan, work and runner views in its own folder,
+         * written after the transcript is closed so they carry all of it. See `writeAttemptRecord`.
+         * A failure to write them is reported and changes nothing about the outcome.
+         */
+        if (status !== 'done') {
+            const now = await store.getSession(session.id);
+            const ended = now?.tasks.find((x) => x.id === task.id);
+            if (now && ended) {
+                await writeAttemptRecord(now, ended, cfg.resolved.runsDir, exportMachine(cfg))
+                    .then((dir) => {
+                    if (dir) {
+                        bus.publish({ sessionId: session.id, taskId: task.id, type: 'attempt-record', level: 'info',
+                            message: `plan, work and runner of this attempt saved in ${dir}`, data: { dir } });
+                    }
+                })
+                    .catch((e) => bus.publish({ sessionId: session.id, taskId: task.id, type: 'attempt-record', level: 'warn',
+                    message: `could not save the plan, work and runner of this attempt: ${e.message}` }));
+            }
+        }
         return { status, iterations, summary, reason };
     };
     await setTask((t) => {
@@ -525,6 +550,7 @@ export async function runTask(transport, session, task, deps) {
         isolation,
         confinedTo: confinement.roots,
         mode: deps.currentMode?.() ?? cfg.execution.mode,
+        networkFetch: cfg.execution.networkFetch,
         allowedPrograms: cfg.execution.allowedPrograms,
         denyPatterns: cfg.execution.denyPatterns,
         cwd: work.cwd,
@@ -1180,7 +1206,7 @@ export async function runTask(transport, session, task, deps) {
             let shellRefused = 0;
             for (const step of reply.steps) {
                 if (signal?.aborted) {
-                    results.push(refusedResult(step, 'stopped by the operator'));
+                    results.push(refusedResult(step, 'stopped by the operator', 'operator'));
                     aborted = true;
                     break;
                 }
@@ -1232,13 +1258,13 @@ export async function runTask(transport, session, task, deps) {
                     t.status = 'running';
                 });
                 if (decision.action === 'abort') {
-                    results.push(refusedResult(step, decision.reason));
+                    results.push(refusedResult(step, decision.reason, decision.by === 'operator' ? 'operator' : 'runner'));
                     aborted = true;
                     break;
                 }
                 if (decision.action === 'skip') {
-                    sink.event('step-skipped', { id: step.id, reason: decision.reason }, `step ${step.id} skipped: ${decision.reason}`, 'warn');
-                    results.push(refusedResult(step, decision.reason));
+                    sink.event('step-skipped', { id: step.id, reason: decision.reason, by: decision.by ?? 'runner' }, `step ${step.id} skipped: ${decision.reason}`, 'warn');
+                    results.push(refusedResult(step, decision.reason, decision.by === 'operator' ? 'operator' : 'runner'));
                     continue;
                 }
                 const long = step.expect === 'long';

package/dist/src/plan/schema.js

@@ -195,6 +195,13 @@ const TaskInput = z.object({
      * branch so nothing is lost and the next task starts clean.
      */
     readOnly: z.boolean().default(false),
+    /**
+     * 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:
+     * accepted so that an exported plan imports again without a warning about it, and then ignored —
+     * an imported task starts from its current text, with no attempts behind it.
+     */
+    earlierAttempts: z.array(z.unknown()).optional(),
 });
 const SessionInput = z.object({
     name: z

package/dist/src/plan/systemGuide.js

@@ -581,16 +581,16 @@ export const SYSTEM_GUIDE = [
                         kind: 'button',
                         en: 'Run this and the rest without asking',
                         bg: 'Изпълни без да питаш повече',
-                        doesEn: 'Runs it and stops asking about every command after it until this run ends, except a command that downloads from the internet. Not offered on such a command.',
-                        doesBg: 'Изпълнява я и спира да пита за следващите команди до края на това пускане, освен за команда, която тегли от интернет. Не се предлага на такава команда.',
+                        doesEn: 'Runs it and stops asking about every command after it until this run ends, except a command that downloads from the internet, which follows the choice in Settings → Execution. Not offered on such a command.',
+                        doesBg: 'Изпълнява я и спира да пита за следващите команди до края на това пускане, освен за команда, която тегли от интернет — за нея важи изборът в Настройки → Изпълнение. Не се предлага на такава команда.',
                     },
                     {
                         key: 'approval.network',
                         kind: 'note',
-                        en: 'This command downloads from the internet. The bot never does that on its own, even in a run that does not ask, because a later step could run what arrived. Run it only if you know what it fetches and why.',
-                        bg: 'Тази команда тегли от интернет. Ботът никога не го прави сам, дори при пускане без питане, защото следваща стъпка може да пусне изтегленото. Изпълнете я само ако знаете какво тегли и защо.',
-                        doesEn: 'Shown on a step that fetches from the network. Such a step waits here in every run, including one that does not ask; requests to localhost and package installs through npm or dotnet do not.',
-                        doesBg: 'Показва се на стъпка, която тегли от мрежата. Такава стъпка чака тук при всяко пускане, включително без питане; заявки към localhost и пакети през npm или dotnet не чакат.',
+                        en: 'This command downloads from the internet. A run that does not ask still stops for this one (unless Settings → Execution says otherwise), because a later step could run what arrived. Run it only if you know what it fetches and why.',
+                        bg: 'Тази команда тегли от интернет. Пускане без питане също спира за нея (освен ако Настройки → Изпълнение не казва друго), защото следваща стъпка може да пусне изтегленото. Изпълнете я само ако знаете какво тегли и защо.',
+                        doesEn: 'Shown on a step that fetches from the network. Such a step waits here in every run, including one that does not ask, unless Settings → Execution has chosen to refuse or run such commands in a run without supervision; requests to localhost and package installs through npm or dotnet never wait.',
+                        doesBg: 'Показва се на стъпка, която тегли от мрежата. Такава стъпка чака тук при всяко пускане, включително без питане, освен ако в Настройки → Изпълнение не е избрано такива команди да се отказват или изпълняват при пускане без надзор; заявки към localhost и пакети през npm или dotnet никога не чакат.',
                     },
                     {
                         key: 'approval.skip',
@@ -1481,6 +1481,14 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'Saves the log of one earlier attempt, rather than of the latest one, to the Desktop.',
                         doesBg: 'Запазва на десктопа log-а на конкретен по-ранен опит, а не на последния.',
                     },
+                    {
+                        key: 'save.attemptRecord',
+                        kind: 'button',
+                        en: 'download plan, work and runner of this attempt',
+                        bg: 'изтегли план, работа и runner на този опит',
+                        doesEn: 'Downloads one earlier attempt as it ran — the plan it was given, what happened to the work, what the runner did — as one file, even if the task was edited since. An attempt that did not end done also keeps the three as plan.json, work.json and runner.json in its run folder.',
+                        doesBg: 'Изтегля един по-ранен опит, както е вървял — планът, който е получил, какво е станало с работата, какво е направил runner-ът — в един файл, дори ако задачата е редактирана след това. Опит, който не е завършил готов, пази трите и като plan.json, work.json и runner.json в папката на пускането си.',
+                    },
                     {
                         key: 'reg.retriedFreshDone',
                         kind: 'badge',
@@ -1700,6 +1708,22 @@ export const SYSTEM_GUIDE = [
                         doesEn: "The operator's statement about what contains this runner: this account, a separate low-privilege Windows account, Windows Sandbox, or a VM. It gates unattended runs — while it says this account, a run with nobody watching is refused, unless the operator chose \"this account — I accept unattended runs without isolation\", which allows it on their responsibility — and it is recorded with every run beside the account the process actually held.",
                         doesBg: 'Твърдението на оператора какво огражда този runner: този акаунт, отделен Windows акаунт с малки права, Windows Sandbox или виртуална машина. То управлява пусканията без надзор — докато казва „този акаунт“, пускане без човек се отказва, освен ако операторът не е избрал „в този акаунт — приемам пускане без надзор без изолация“, което го позволява на негова отговорност — и се записва с всяко пускане до акаунта, който процесът наистина е държал.',
                     },
+                    {
+                        key: 'exec.startMode',
+                        kind: 'select',
+                        en: 'Starting a run without supervision',
+                        bg: 'Пускане без надзор',
+                        doesEn: 'Whether the run buttons that work through the queue on their own ask "are you sure" first ("Ask \"are you sure\" every time", the default) or simply start ("Start it without asking"). Step by step stays available beside them either way.',
+                        doesBg: 'Дали бутоните, които минават през опашката сами, питат първо „сигурен ли си“ („Питай „сигурен ли си“ всеки път“, по подразбиране) или просто тръгват („Пускай, без да питаш“). „Стъпка по стъпка“ остава до тях и в двата случая.',
+                    },
+                    {
+                        key: 'exec.networkFetch',
+                        kind: 'select',
+                        en: 'A command that downloads, in a run without supervision',
+                        bg: 'Команда, която тегли от интернет, при пускане без надзор',
+                        doesEn: 'What a run without supervision does with Invoke-WebRequest, curl, wget and the like: wait for the operator on the approval screen (the default), refuse it and tell the chat why so the run never waits, or run it without anyone reading it. Recorded in every task. A step-by-step run shows every command whatever is chosen.',
+                        doesBg: 'Какво прави пускане без надзор с Invoke-WebRequest, curl, wget и подобни: чака оператора на екрана за одобрение (по подразбиране), отказва я и казва на чата защо, така че пускането никога не чака, или я изпълнява, без никой да я е прочел. Записва се във всяка задача. При „стъпка по стъпка“ всяка команда се показва, каквото и да е избрано.',
+                    },
                 ],
             },
         ],

package/dist/src/protocol/reporter.js

@@ -20,13 +20,15 @@ function outcomeSummary(r) {
             return `step ${r.id} hit its time limit`;
         case 'idle-timeout':
             return `step ${r.id} produced no output and was stopped`;
+        case 'refused':
+            // The runner declined it — a policy, a deny pattern, a repeat, damaged text, a shell that is
+            // not here — and it never reached a process, so it has no exit code to report. Said as a
+            // refusal, apart from a step that ran and exited non-zero: the move after one is to write
+            // the step differently, after the other it is to read the output and fix the work.
+            return `step ${r.id} was refused by the runner and never ran (no exit code); the reason is under it`;
         case 'aborted':
-            // Exit -4 is `refusedResult`: the runner declined it — a deny pattern, a repeat, damaged
-            // text, a shell that is not here — and it never reached a process. Calling all of those
-            // "aborted by the operator" told the model a person had stopped it, which is a reason to
-            // wait rather than to write the step again, and the reason it could act on was in the
-            // stderr underneath a sentence contradicting it.
-            return r.exitCode === -4 ? `step ${r.id} was not run; see why under it` : `step ${r.id} aborted by the operator`;
+            // A person stopped or skipped it — a reason to carry on without it, not to rewrite it.
+            return r.exitCode === -4 ? `step ${r.id} was not run: the operator skipped or stopped it` : `step ${r.id} aborted by the operator`;
         case 'spawn-error':
             return `step ${r.id} could not be started`;
     }

package/dist/src/session/exports.js

@@ -18,7 +18,8 @@
  * All three exist for one task and for one run, because those are the two sizes a question
  * comes in: "why did this one fail" and "what did this whole run do".
  */
-import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { withoutPersona } from '../plan/importPlan.js';
 const EXPECTED_HEADER = '### Expected result';
@@ -164,6 +165,9 @@ export function buildPlanExport(scope) {
                         task.review = false;
                     if (t.readOnly)
                         task.readOnly = true;
+                    const earlier = earlierPlans(t, level2);
+                    if (earlier.length > 0)
+                        task.earlierAttempts = earlier;
                     return task;
                 }),
             };
@@ -171,6 +175,129 @@ export function buildPlanExport(scope) {
         }),
     };
 }
+/**
+ * What each earlier attempt of a task was asked, in the plan's own words.
+ *
+ * The plan is the task as it is now, and after "Edit and run again" that is not what the failed
+ * attempt ran: its text, its checks, its branch plan may all have changed. The attempt's own
+ * snapshot is here, beside it, so the plan of a failure can be read — and handed on — after the
+ * task has moved past it. Only what differs from the task as it stands is written out; an attempt
+ * that ran the same plan says so by its status alone. The importer ignores this key: a plan that
+ * comes back in is the current one.
+ */
+function earlierPlans(t, sessionLevel2) {
+    const current = splitPrompt(t.prompt);
+    return (t.attempts ?? []).map((a, i) => {
+        const out = { attempt: i + 1, status: a.status };
+        if (a.reason)
+            out.reason = a.reason;
+        if (a.title !== t.title)
+            out.title = a.title;
+        const p = splitPrompt(a.prompt);
+        if (p.prompt !== current.prompt)
+            out.prompt = p.prompt;
+        if (p.expected !== current.expected)
+            out.expected = p.expected;
+        const aLevel2 = planLevel2({ ...t, level2: a.level2 });
+        if (aLevel2 !== planLevel2(t))
+            out.level2 = aLevel2 === sessionLevel2 ? '' : aLevel2;
+        if (a.checks && JSON.stringify(a.checks) !== JSON.stringify(t.checks ?? []))
+            out.checks = a.checks.map(planCheck);
+        if (a.vcsPlan && JSON.stringify(a.vcsPlan) !== JSON.stringify(t.vcsPlan ?? {}))
+            out.vcs = a.vcsPlan;
+        return out;
+    });
+}
+// ------------------------------------------------------------------------------------------
+// one attempt, as it was
+// ------------------------------------------------------------------------------------------
+/**
+ * The task as it stood for one of its attempts: that attempt's text, checks, outcome and run
+ * folder, with only the attempts before it as its history. The current attempt is the task
+ * itself. Null for an attempt the task never had.
+ *
+ * This is what lets every view above be taken of a past attempt without a second set of
+ * builders: the views read a task, and this hands them the task that attempt was.
+ */
+export function taskAtAttempt(task, attempt) {
+    const current = task.attempt ?? 1;
+    if (attempt === current)
+        return task;
+    if (!Number.isInteger(attempt) || attempt < 1 || attempt > current)
+        return null;
+    const a = task.attempts?.[attempt - 1];
+    if (!a)
+        return null;
+    return {
+        ...task,
+        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,
+        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,
+        attempts: task.attempts?.slice(0, attempt - 1),
+        continuing: undefined,
+        finalReply: undefined,
+        firstMessage: undefined,
+        logFile: a.runId ? 'task-log.txt' : undefined,
+    };
+}
+/** The session with one of its tasks replaced, so a scope can be built around that version. */
+export function withTask(session, task) {
+    return { ...session, tasks: session.tasks.map((t) => (t.id === task.id ? task : t)) };
+}
+/** What the runner export says about the machine, from the configuration in force. */
+export function exportMachine(cfg) {
+    return {
+        node: process.versions.node,
+        platform: process.platform,
+        cwd: cfg.resolved.cwd,
+        limits: { ...cfg.limits, execution: { commandTimeoutSec: cfg.execution.commandTimeoutSec, idleTimeoutSec: cfg.execution.idleTimeoutSec, mode: cfg.execution.mode } },
+    };
+}
+/** The three files an attempt that did not end done leaves in its own run folder. */
+export const ATTEMPT_RECORD_FILES = { plan: 'plan.json', work: 'work.json', runner: 'runner.json' };
+/**
+ * Writes the plan, work and runner views of an attempt into its run folder, and returns the folder.
+ *
+ * For an attempt that did not end done, written as it ends. The same three views can be
+ * downloaded at any time — but only while the task's record exists and still describes that
+ * attempt: a deleted task or session takes the record with it, and the files are then the only
+ * account of what the failure was asked, did and ran into. The run folder outlives both (it goes
+ * only by `runsRetentionDays`), which is why they are kept there, beside the transcript they are
+ * read from. Null when the attempt has no run folder, which is an attempt that never started.
+ */
+export async function writeAttemptRecord(session, task, runsDir, machine) {
+    if (!task.runId)
+        return null;
+    const dir = join(runsDir, task.runId);
+    if (!existsSync(dir))
+        return null;
+    const scope = {
+        sessions: [withTask(session, task)],
+        taskFilter: (_s, t) => t.id === task.id,
+        label: `${session.name}-${task.title}-attempt-${task.attempt ?? 1}`,
+    };
+    const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+    await writeFile(join(dir, ATTEMPT_RECORD_FILES.plan), json(buildPlanExport(scope)), 'utf8');
+    await writeFile(join(dir, ATTEMPT_RECORD_FILES.work), json(await buildDomainExport(scope, runsDir)), 'utf8');
+    await writeFile(join(dir, ATTEMPT_RECORD_FILES.runner), json(await buildBotExport(scope, runsDir, machine)), 'utf8');
+    return dir;
+}
 async function readEvents(runsDir, runId) {
     if (!runId)
         return [];

package/dist/src/session/store.js

@@ -335,6 +335,8 @@ export class SessionStore {
                     prompt: t.prompt,
                     level2: t.level2,
                     checkResults: t.checkResults,
+                    checks: t.checks,
+                    vcsPlan: t.vcsPlan,
                     review: t.review,
                     vcs: t.vcs,
                 },

package/dist/src/vcs/taskVcs.js

@@ -225,6 +225,39 @@ export async function commitTaskResult(session, task, outcome, bus) {
     }
     return { ...current, commit: result.commit, commits, files, ...(suspicious.length > 0 ? { suspicious } : {}) };
 }
+/**
+ * Commits what a task left behind when the process running it ended before it could.
+ *
+ * `commitTaskResult` runs when a task finishes, whatever the outcome, which covers every failure
+ * the runner itself decides. It does not cover the process going away mid-task — `npm start`
+ * stopped with Ctrl+C, a restart, a crash, the laptop shutting down. Then nothing committed the
+ * work: at the next start the task was only marked aborted, its changes stayed loose in the tree,
+ * and the next attempt found a dirty repository and ran with version control switched off — so
+ * the first attempt's work was neither on a branch nor carried forward, and one `git checkout .`
+ * from gone. Called at startup for each task the recovery pass closes.
+ *
+ * Only on the task's own branch. The runner created that branch for this task and the process
+ * that owned it is gone, so what is uncommitted there is the task's work; a repository that has
+ * since been moved to another branch is someone's deliberate act, and is left alone with a
+ * warning, as a dirty tree is left alone before a task.
+ */
+export async function commitInterrupted(session, task, reason, bus) {
+    const settings = session.vcs;
+    const branch = task.vcs?.branch;
+    if (!settings?.enabled || !settings.commitOnFinish || !branch)
+        return undefined;
+    const dir = repoDirOf(session);
+    const state = await repoState(dir);
+    if (!state.isRepo || !state.dirty)
+        return undefined;
+    if (state.branch !== branch) {
+        bus.publish({ sessionId: session.id, taskId: task.id, type: 'vcs-problem', level: 'warn',
+            message: `"${task.title}" was interrupted with uncommitted changes, but ${dir} is now on ${state.branch ?? 'no branch'}, ` +
+                `not on the task's branch ${branch}; nothing was committed, so the changes are where they are` });
+        return undefined;
+    }
+    return await commitTaskResult(session, task, { status: 'aborted', reason }, bus);
+}
 /**
  * A commit message that says what was asked and how it ended, in git's own shape.
  *