copilot-operator 0.1.4 → 0.1.6

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

@@ -133,7 +133,8 @@ let OperatorController = class OperatorController {
         return this.ops.continueTask(id, taskId).catch(fail);
     }
     rerunTask(id, taskId, body) {
-        return this.ops.rerunTask(id, taskId, body ?? {}).catch(fail);
+        const { buildOnFinished, ...patch } = body ?? {};
+        return this.ops.rerunTask(id, taskId, patch, { buildOnFinished: buildOnFinished === true }).catch(fail);
     }
     /** What going back to before this task would do. Changes nothing. */
     restorePreview(id, taskId) {
@@ -320,13 +321,15 @@ let OperatorController = class OperatorController {
     startBatch(body) {
         if (!Array.isArray(body?.sessionIds))
             throw new BadRequestException('sessionIds must be a list of session ids');
+        if (body?.taskIds !== undefined && !Array.isArray(body.taskIds))
+            throw new BadRequestException('taskIds must be a list of task ids');
         return this.ops
             .startBatch(body.sessionIds, body?.mode === 'unattended' ? 'unattended' : 'confirm', body?.onFailure === 'continue' ? 'continue' : 'stop', 
         // Absent or empty means every session keeps the model it already has, which is not the
         // same as "no model": an empty string on a session means "leave the chat alone".
         body?.model, 
         // The same for the review: absent means each session keeps whatever it is set to.
-        body?.reviewModel, body?.name)
+        body?.reviewModel, body?.name, body?.taskIds)
             .catch(fail);
     }
     stopBatch() {

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

@@ -20,7 +20,7 @@ import { installLayout } from '../config/layout.js';
 import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW } from '../session/store.js';
 import { EventBus } from '../session/events.js';
 import { newId, tidyVcsPlan } from '../session/model.js';
-import { runSession, openBrowser } from '../orchestrator/taskRunner.js';
+import { runSession, openBrowser, queuedToRun } from '../orchestrator/taskRunner.js';
 import { buildExport } from '../session/exportRecord.js';
 import { buildDebugExport } from '../session/debugExport.js';
 import { buildPlanExport, buildDomainExport, buildBotExport, buildBundleExport, exportFileName, exportMachine, taskAtAttempt, withTask, writeAttemptRecord } from '../session/exports.js';
@@ -249,6 +249,20 @@ let OperatorService = class OperatorService {
                     if (reason)
                         throw new Error(reason);
                 }
+                if (merged.baseBranch !== undefined)
+                    merged.baseBranch = merged.baseBranch.trim();
+                /*
+                 * Where the session starts is fixed at its first run. A new choice clears that record, so
+                 * the next task to run is cut from what was chosen now; the tasks that already ran keep
+                 * their own base commits, which is what a re-run of them goes back to.
+                 */
+                const startChanged = (merged.startFrom ?? 'head') !== (s.vcs?.startFrom ?? 'head') ||
+                    (merged.baseBranch || 'main') !== (s.vcs?.baseBranch || 'main') ||
+                    merged.repoDir.toLowerCase() !== (s.vcs?.repoDir ?? '').trim().toLowerCase();
+                if (startChanged) {
+                    s.vcsBaseCommit = undefined;
+                    s.vcsStart = undefined;
+                }
                 s.vcs = merged;
             }
         });
@@ -314,16 +328,26 @@ let OperatorService = class OperatorService {
         });
         return task;
     }
-    async rerunTask(sessionId, taskId, patch = {}) {
+    async rerunTask(sessionId, taskId, patch = {}, 
+    /**
+     * A new prompt for a task that ended done builds on what it did: the next attempt works on
+     * that attempt's branch. Only for a done task — a failed attempt's work is what is being
+     * replaced, so a re-run of one starts again from where the task first started.
+     */
+    opts = {}) {
         await this.init();
-        const task = await this.store.rerunTask(sessionId, taskId, patch);
+        const before = (await this.store.getSession(sessionId))?.tasks.find((t) => t.id === taskId);
+        const buildsOn = opts.buildOnFinished && before?.status === 'done' ? { fromAttempt: before.attempt ?? 1 } : undefined;
+        const task = await this.store.rerunTask(sessionId, taskId, patch, undefined, buildsOn);
         this.bus.publish({
             sessionId,
             taskId,
             type: 'task-requeued',
             level: 'info',
-            message: `"${task.title}" is queued again (attempt ${task.attempt ?? 1})`,
-            data: { attempt: task.attempt },
+            message: buildsOn
+                ? `"${task.title}" is queued again with a new prompt that builds on attempt ${buildsOn.fromAttempt} (attempt ${task.attempt ?? 1})`
+                : `"${task.title}" is queued again (attempt ${task.attempt ?? 1})`,
+            data: { attempt: task.attempt, ...(buildsOn ? { buildsOn } : {}) },
         });
         return task;
     }
@@ -629,7 +653,9 @@ let OperatorService = class OperatorService {
     /** A browser that is already open. A batch passes its own; a single run opens one. */
     transport, 
     /** The press of a start button this belongs to, stamped onto every task it reaches. */
-    runGroup) {
+    runGroup, 
+    /** Only these queued tasks, when the operator chose some; the rest stay queued. */
+    onlyTasks) {
         await this.init();
         // Every project's Desktop copy brought up to date before the chat opens, when the operator
         // asked for that. Before the run rather than before each task: a task's own mirror already
@@ -641,7 +667,7 @@ let OperatorService = class OperatorService {
         const session = await this.store.getSession(sessionId);
         if (!session)
             return { started: false, reason: 'no such session', done: Promise.resolve(idle) };
-        const queuedIds = session.tasks.filter((t) => t.status === 'queued').map((t) => t.id);
+        const queuedIds = queuedToRun(session, onlyTasks).map((t) => t.id);
         if (queuedIds.length === 0)
             return { started: false, reason: 'no queued tasks', done: Promise.resolve(idle) };
         const cfg = await this.settings.load();
@@ -700,6 +726,7 @@ let OperatorService = class OperatorService {
             continueOnFailure: session.onFailure === 'continue',
             transport,
             runGroup,
+            onlyTasks,
         })
             .then(async (outcome) => ({ ...(await this.tally(sessionId, queuedIds)), paused: outcome.paused }))
             .catch(async (e) => {
@@ -802,8 +829,15 @@ let OperatorService = class OperatorService {
      */
     reviewModel, 
     /** What to call the run. Offered from the plan's name; empty means it goes by its id. */
-    name) {
+    name, 
+    /**
+     * The queued tasks to run, when not every queued task of those sessions: what the operator
+     * ticked in the register. A session none of whose chosen tasks is queued is skipped; the
+     * tasks nobody chose stay queued exactly as they were. Absent means every queued task.
+     */
+    taskIds) {
         await this.init();
+        const onlyTasks = taskIds && taskIds.length > 0 ? new Set(taskIds.map((t) => t.trim()).filter(Boolean)) : undefined;
         if (this.batch?.running)
             return { started: false, reason: 'a batch is already running' };
         const wanted = [...new Set(sessionIds.map((s) => s.trim()).filter(Boolean))];
@@ -823,9 +857,9 @@ let OperatorService = class OperatorService {
                 sessions.push({ sessionId: id, name: id, state: 'skipped', ran: 0, failed: 0, reason: 'no such session' });
                 continue;
             }
-            const queued = s.tasks.filter((t) => t.status === 'queued').length;
+            const queued = queuedToRun(s, onlyTasks).length;
             sessions.push(queued === 0
-                ? { sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: 'nothing queued' }
+                ? { sessionId: id, name: s.name, state: 'skipped', ran: 0, failed: 0, reason: onlyTasks ? 'none of its chosen tasks is queued' : 'nothing queued' }
                 : { sessionId: id, name: s.name, state: 'waiting', ran: 0, failed: 0 });
         }
         if (!sessions.some((s) => s.state === 'waiting')) {
@@ -885,6 +919,7 @@ let OperatorService = class OperatorService {
             id: newId('b-'),
             startedAt: new Date().toISOString(),
             name: chosenName,
+            ...(onlyTasks ? { onlyTasks: [...onlyTasks] } : {}),
             mode,
             onFailure,
             stopping: false,
@@ -1031,7 +1066,8 @@ let OperatorService = class OperatorService {
                     s.runGroup = {
                         ...runGroup,
                         order: at,
-                        taskIds: s.tasks.filter((t) => t.status === 'queued').map((t) => t.id),
+                        // What this run was asked to do: the chosen tasks, when some were chosen.
+                        taskIds: queuedToRun(s, batch.onlyTasks).map((t) => t.id),
                         mode: batch.mode,
                         onFailure: batch.onFailure,
                     };
@@ -1061,7 +1097,7 @@ let OperatorService = class OperatorService {
                     message: `starting as part of a batch of ${batch.sessions.length} session(s), in ${batch.mode} mode`,
                     data: { batchId: batch.id },
                 });
-                const begun = await this.beginRun(entry.sessionId, batch.mode, browser, runGroup);
+                const begun = await this.beginRun(entry.sessionId, batch.mode, browser, runGroup, batch.onlyTasks ? new Set(batch.onlyTasks) : undefined);
                 if (!begun.started) {
                     entry.state = 'skipped';
                     entry.reason = begun.reason;

package/dist/src/orchestrator/taskRunner.js

@@ -567,7 +567,7 @@ export async function runTask(transport, session, task, deps) {
         // --- version control: a branch of this task's own, before anything is touched -------
         const prepared = await prepareForTask(session, task, bus, async (mutate) => {
             await store.updateSession(session.id, mutate);
-        });
+        }, () => store.listSessions());
         if (prepared.vcs.branch || prepared.vcs.problem) {
             await setTask((t) => {
                 t.vcs = prepared.vcs;
@@ -626,6 +626,7 @@ export async function runTask(transport, session, task, deps) {
             taskNumber,
             contractAlreadySent: session.contractSent,
             continuing: task.continuing,
+            buildsOn: task.buildsOn,
             workDirNote: workingDirNote(work),
             vcsNote: prepared.note,
             readOnlyNote: task.readOnly ? READ_ONLY_NOTE : undefined,
@@ -1462,6 +1463,15 @@ export async function runTask(transport, session, task, deps) {
         return await finish('failed', crash ? `${describeCrash(crash)}. Then: ${message}` : message);
     }
 }
+/**
+ * The queued tasks of a session a run takes: all of them, or only the ones the operator chose.
+ * One rule for the run itself and for every place that counts or records what a run will do, so
+ * the batch entrance, the run's record and the run cannot disagree about it.
+ */
+export function queuedToRun(session, onlyTasks) {
+    const only = onlyTasks ? new Set(onlyTasks) : undefined;
+    return session.tasks.filter((t) => t.status === 'queued' && (!only || only.has(t.id)));
+}
 /**
  * Runs every queued task of a session, in order, in one conversation. Stops at the first
  * task that does not end with `done` unless `continueOnFailure` is set, because a failed
@@ -1472,7 +1482,7 @@ export async function runSession(sessionId, deps) {
     let session = await store.getSession(sessionId);
     if (!session)
         throw new Error(`Session ${sessionId} does not exist.`);
-    const queued = session.tasks.filter((t) => t.status === 'queued');
+    const queued = queuedToRun(session, deps.onlyTasks);
     if (queued.length === 0) {
         bus.publish({ sessionId, type: 'session-idle', level: 'info', message: 'no queued tasks' });
         return { ran: 0, paused: false };