copilot-operator 0.1.13 → 0.1.16

package/dist/src/orchestrator/review.js

@@ -28,6 +28,8 @@ import { effectiveShell, preferredShell, refusalForChat, resolveShell, shellNote
 import { describeStep, checkCommandRefusal } from '../exec/policy.js';
 import { validateDerivedChecks } from './derivedChecks.js';
 import { writeReport } from '../exec/reportFile.js';
+import { mergeRedactions } from '../exec/redaction.js';
+import { trackedRepoOf } from '../vcs/taskVcs.js';
 import { buildCoveringMessage, assertSendable } from '../protocol/reporter.js';
 /** The sentence both sides get when a review left something listening. */
 function leftoverNote(leftovers) {
@@ -50,7 +52,8 @@ export function deliverableFor(task, summary, tracked, changedFiles) {
     return undefined;
 }
 export function reviewBrief(session, task, changedFiles, cwd, deviations = [], previous, disputes = [], derivedFailing = [], earlier = [], deliverable) {
-    const repo = session.vcs?.enabled ? session.vcs.repoDir?.trim() : '';
+    // The same repository the runner branched and read the changed files from, however it is named.
+    const repo = trackedRepoOf(session);
     const files = changedFiles.length > 0 ? changedFiles.map((f) => `- ${f}`).join('\n') : '(version control recorded no file changes for this task)';
     return [
         '## The task that was given',
@@ -224,8 +227,8 @@ export async function runReview(transport, session, task, deps) {
         // The machine's shells, when they are not what the contract's example assumes — the same note
         // the implementer's conversation opens with, for a conversation working to the same example.
         const machineNote = shellNote(undefined, defaultShell);
-        let before = await transport.sendAndConfirm(machineNote ? `${contract}
-
+        let before = await transport.sendAndConfirm(machineNote ? `${contract}
+
 ${machineNote}` : contract);
         await transport.waitForReply(before);
         await pacer.throttleSend();
@@ -375,10 +378,17 @@ ${machineNote}` : contract);
                     defaultShell,
                     tracker: deps.tracker,
                     passEnv: cfg.execution.passEnv,
+                    // What these checks say goes back to the reviewer (below) and into the next brief, so it
+                    // is redacted with the operator's patterns where it is said, as the gate's checks are.
+                    redactPatterns: cfg.report.redactPatterns,
                 });
                 if (validation.refused.length > 0 && !derivedRetried) {
                     derivedRetried = true;
                     deps.event('review-check-refused', { round, refused: validation.refused.map((r) => r.finding.id) }, `${validation.refused.length} check(s) given with findings pass on the work as it is, so they do not capture the defect; sent back once`, 'warn');
+                    const redactions = mergeRedactions(validation.refused.map((r) => r.outcome.redactions ?? []));
+                    if (redactions.length > 0) {
+                        deps.event('report-redacted', { round, refusedChecks: true, redactions }, `redacted from the checks sent back to the reviewer: ${redactions.map((r) => `${r.count}× ${r.name}`).join(', ')}`, 'warn');
+                    }
                     await pacer.throttleSend();
                     const b = await transport.sendAndConfirm(refusedChecksMessage(validation.refused.map((r) => ({ id: r.finding.id, detail: r.outcome.detail }))));
                     markdown = (await transport.waitForReply(b)).markdown;
@@ -463,6 +473,9 @@ ${machineNote}` : contract);
                 stepsRun += 1;
                 results.push(result);
                 deps.event('review-step-finished', { round, id: step.id, outcome: result.outcome, exitCode: result.exitCode, shell: result.shell, requestedShell: result.requestedShell ?? null, shellPath: result.shellPath ?? '' }, `review step ${step.id}: ${result.outcome}, exit ${result.exitCode}, ${(result.durationMs / 1000).toFixed(1)}s`);
+                // Stopped while it ran: no step after it is started, and the report waits below.
+                if (signal?.aborted)
+                    break;
                 await pacer.settle();
             }
             const report = await writeReport(results, {
@@ -479,6 +492,15 @@ ${machineNote}` : contract);
             if (report.redactions.length > 0) {
                 deps.event('report-redacted', { round, iteration: iterations, redactions: report.redactions }, `redacted before upload: ${report.redactions.map((r) => `${r.count}× ${r.name}`).join(', ')}`, 'warn');
             }
+            /*
+             * Stopped while a step ran. Looked at only at the top of the loop, the signal let the report of
+             * the cut-short step be uploaded and the reviewer's answer be waited for before the review
+             * noticed. The runner's chat refuses to send once the run is stopped (`sendsUntilStopped`),
+             * but that is the runner covering for this loop; the review ends on a Stop by itself, the way
+             * the runner's own loop does: the report is written for the record and nothing more is sent.
+             */
+            if (signal?.aborted)
+                return { verdict: 'error', findings: [], stepsRun, iterations, problem: 'the run was stopped' };
             const covering = buildCoveringMessage({
                 task: `review of "${task.title}"`,
                 iteration: iterations,