copilot-operator 0.1.9 → 0.1.10

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

@@ -17,9 +17,9 @@ import { readFile, readdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { installLayout } from '../config/layout.js';
-import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW } from '../session/store.js';
+import { SessionStore, DEFAULT_VCS, DEFAULT_REVIEW, applyTaskPatch } from '../session/store.js';
 import { EventBus } from '../session/events.js';
-import { newId, tidyVcsPlan } from '../session/model.js';
+import { newId } from '../session/model.js';
 import { runSession, openBrowser, queuedToRun } from '../orchestrator/taskRunner.js';
 import { buildExport } from '../session/exportRecord.js';
 import { buildDebugExport } from '../session/debugExport.js';
@@ -303,16 +303,7 @@ let OperatorService = class OperatorService {
         return await this.store.updateTask(sessionId, taskId, (t) => {
             if (t.status !== 'queued')
                 throw new Error('Only a queued task can be edited.');
-            if (patch.title !== undefined)
-                t.title = patch.title;
-            if (patch.level2 !== undefined)
-                t.level2 = patch.level2;
-            if (patch.prompt !== undefined)
-                t.prompt = patch.prompt;
-            if (patch.vcsPlan !== undefined)
-                t.vcsPlan = tidyVcsPlan(patch.vcsPlan);
-            if (patch.checks !== undefined)
-                t.checks = patch.checks.filter((c) => c.name.trim() !== '');
+            applyTaskPatch(t, patch);
         });
     }
     async deleteTask(sessionId, taskId) {
@@ -2035,6 +2026,7 @@ let OperatorService = class OperatorService {
                     disputes: t.disputes?.length || undefined,
                     readOnly: t.readOnly || undefined,
                     scope: t.scope?.length ? t.scope : undefined,
+                    stopCode: t.stopCode,
                     autoRetries: t.autoRetries || undefined,
                     attempt: t.attempt,
                     changedFiles: t.vcs?.commit && t.vcs.baseCommit ? (t.vcs.files?.length ?? 0) : undefined,

package/dist/src/orchestrator/contract.js

@@ -0,0 +1,58 @@
+/**
+ * Whether a task can be satisfied at all, decided before anything is sent to the chat.
+ *
+ * A task is a contract: a prompt, the checks that say when it is done, and what it may change
+ * (`readOnly`, `scope`). The three are written at different times — a plan, an edit, a new prompt on
+ * a finished task — and they can end up contradicting each other: an audit made read-only that
+ * still carries the old "the file now says X" check; a task scoped to its tests that must change
+ * the config to pass. Run as it is, such a task spends its rounds and ends blocked on a check the
+ * chat could never have met. This names the contradiction instead, before the first message.
+ *
+ * Only what can be known without running anything is judged: the flags against each other, and
+ * the file checks against the tree as it is now. A file check that already passes needs no change;
+ * one that fails needs its file changed, which a read-only task, or a scope that leaves the file
+ * out, forbids. Command checks are not judged: whether a command will pass depends on work the
+ * task is allowed to do elsewhere.
+ */
+import { readFile, stat } from 'node:fs/promises';
+import { isAbsolute, relative, resolve } from 'node:path';
+import { inScope } from '../vcs/scope.js';
+async function fileCheckPassesNow(check, cwd) {
+    const path = resolve(cwd, (check.cwd ?? '').trim() || '.', (check.file ?? '').trim());
+    const info = await stat(path).catch(() => null);
+    const exists = !!info?.isFile();
+    if (check.expect === 'file-exists')
+        return { passes: exists, path };
+    if (check.expect === 'file-missing')
+        return { passes: !exists, path };
+    const text = exists ? await readFile(path, 'utf8').catch(() => '') : '';
+    return { passes: exists && text.includes(check.value ?? ''), path };
+}
+/** Each contradiction in the task, as a sentence; empty when it can be satisfied. */
+export async function contractConflicts(task, cwd, repoDir) {
+    const out = [];
+    const scope = task.scope ?? [];
+    if (task.readOnly && scope.length > 0) {
+        out.push(`It is read-only, which allows no change, and also scoped to ${scope.join(', ')}, which allows changes there.`);
+    }
+    if (!task.readOnly && scope.length === 0)
+        return out;
+    const checks = [
+        ...(task.checks ?? []),
+        ...(task.reviewChecks ?? []).filter((rc) => rc.state === 'active').map((rc) => rc.check),
+    ].filter((c) => c.expect === 'file-exists' || c.expect === 'file-missing' || c.expect === 'file-contains');
+    for (const check of checks) {
+        const { passes, path } = await fileCheckPassesNow(check, cwd);
+        if (passes)
+            continue;
+        const rel = relative(resolve(repoDir), path).replace(/\\/g, '/');
+        const inside = rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
+        if (task.readOnly) {
+            out.push(`The check "${check.name}" fails now and can only pass if ${rel || path} changes, but the task is read-only.`);
+        }
+        else if (inside && !inScope(rel, scope)) {
+            out.push(`The check "${check.name}" fails now and can only pass if ${rel} changes, but the task's scope (${scope.join(', ')}) leaves that file out.`);
+        }
+    }
+    return out;
+}

package/dist/src/orchestrator/taskRunner.js

@@ -41,6 +41,7 @@ import { composeOpening, READ_ONLY_NOTE } from '../session/compose.js';
 import { enforceScope, scopeMessage, scopeNote } from '../vcs/scope.js';
 import { composeHandoff } from '../session/handoff.js';
 import { ProgressWatch } from './progress.js';
+import { contractConflicts } from './contract.js';
 import { treeFingerprint } from '../vcs/git.js';
 import { mirrorProject, describeMirror } from '../context/projectMirror.js';
 import { projectNameFor, projectTargetDir, removeLegacyFlatMirror } from '../context/desktopMirror.js';
@@ -366,6 +367,12 @@ export async function runTask(transport, session, task, deps) {
     const progress = new ProgressWatch({ noProgress: Math.max(2, cfg.limits.maxNoProgressRounds ?? 3), oscillations: 2 });
     /** Set when a check round shows no progress; the give-up then ends the task blocked with it. */
     let noProgressReason = null;
+    /**
+     * Why the attempt stopped, when the status alone does not say: a format the chat could not keep,
+     * a task contract that contradicts itself, a loop, a check that could never run, a machine that
+     * lacks a shell. Written by `finish`. See `Task.stopCode`.
+     */
+    let stopCode;
     /**
      * Checks earlier reviews gave with their findings — carried over from every attempt before
      * this one, and grown by this one. See `derivedChecks.ts` for the three rules.
@@ -467,6 +474,8 @@ export async function runTask(transport, session, task, deps) {
                 t.reviewChecks = reviewChecks;
             t.logFile = 'task-log.txt';
             t.stats = stats;
+            if (stopCode)
+                t.stopCode = stopCode;
         });
         // The end in one fixed shape, read off the record just written. See `session/handoff.ts`.
         await setTask((t) => {
@@ -606,9 +615,31 @@ export async function runTask(transport, session, task, deps) {
          * is the task's, and the starting commit is what a change goes back to.
          */
         const scope = task.scope ?? [];
-        const scopeEnforced = scope.length > 0 && !!prepared.vcs.branch && !prepared.vcs.problem && !!prepared.vcs.baseCommit;
+        const onOwnBranch = !!prepared.vcs.branch && !prepared.vcs.problem && !!prepared.vcs.baseCommit;
+        /*
+         * A read-only task is a scope of nothing, and is enforced the same way: whatever a round changed
+         * is put back before the chat reads the results. It used to be judged only at the end, so an
+         * audit that edited a file "to check something" kept the edit through every later round and its
+         * findings described a tree that was not the one it had been asked to audit.
+         */
+        const scopeEnforced = (scope.length > 0 || !!task.readOnly) && onOwnBranch;
         /** 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;
+        /*
+         * The task's contract, checked before a single message is sent.
+         *
+         * A task can be written so that no answer satisfies it: read-only and still given paths to
+         * change, or a check that needs a file to change while the task may not change it. Sent as it
+         * is, the chat works for rounds, the check fails at the end, and the task goes blocked on a
+         * finding the chat could never have fixed. The contradiction is named instead, now, and nothing
+         * is run. See `orchestrator/contract.ts`.
+         */
+        const conflicts = await contractConflicts(task, work.cwd, repoDirOf(session) || work.cwd);
+        if (conflicts.length > 0) {
+            stopCode = 'contract-conflict';
+            sink.event('contract-conflict', { conflicts }, `the task contradicts itself: ${conflicts.join(' | ')}`, 'error');
+            return await finish('blocked', `the task contradicts itself, so it was not started: ${conflicts.join(' ')} Change the prompt, the checks, the scope or read-only, and queue it again.`);
+        }
         // --- project mirror, attached to the first message of the task ---------------------
         let mirrorFiles = [];
         if (session.mirror.enabled && session.mirror.rootDir) {
@@ -819,6 +850,7 @@ export async function runTask(transport, session, task, deps) {
             if (stuck) {
                 noProgressReason = stuck;
                 stats.stoppedFor = 'no-progress';
+                stopCode = 'no-progress';
                 sink.event('no-progress', { kind: 'checks' }, stuck, 'warn');
                 return 'give-up';
             }
@@ -1155,9 +1187,20 @@ export async function runTask(transport, session, task, deps) {
                 formatRetries += 1;
                 stats.formatErrors += 1;
                 sink.event('format-error', { reason: parsed.reason, detail: parsed.detail }, `reply did not match the contract (${parsed.reason}), retry ${formatRetries}/${cfg.limits.maxFormatRetries}`, 'warn');
+                /*
+                 * Out of format retries: stopped at a limit, not failed.
+                 *
+                 * Nothing about the work went wrong here — the steps that ran are recorded, their output is
+                 * in the run folder, and the rejected replies ran nothing. So the task ends `limit-reached`,
+                 * marked `format-repair-exhausted`, which is what lets "Continue in the same chat" carry it
+                 * on from exactly here instead of the operator having to run it again from the start. It
+                 * used to end `failed`, which read as a verdict on the work and offered only a fresh start.
+                 */
                 if (formatRetries > cfg.limits.maxFormatRetries) {
                     await transport.dumpFailure(log.path('failures'), 'format-error');
-                    return await finish('failed', `Copilot did not keep the output contract: ${parsed.detail}`, undefined, lastMarkdown);
+                    stopCode = 'format-repair-exhausted';
+                    return await finish('limit-reached', `format repair exhausted: ${formatRetries} replies in a row did not match the format (maxFormatRetries ${cfg.limits.maxFormatRetries}), ` +
+                        `the last because ${parsed.detail}. Nothing from those replies was run; the work so far is kept.`, undefined, lastMarkdown);
                 }
                 await pacer.throttleSend();
                 const before = await transport.sendAndConfirm(formatErrorMessage(parsed, formatRetries, cfg.limits.maxFormatRetries));
@@ -1167,6 +1210,9 @@ export async function runTask(transport, session, task, deps) {
                 continue;
             }
             formatRetries = 0;
+            if (parsed.coerced) {
+                sink.event('format-coerced', { fields: parsed.coerced }, `read as text: ${parsed.coerced.join(', ')} arrived in another shape; nothing in them is run, so the reply was taken as it was`);
+            }
             iterations += 1;
             await setTask((t) => {
                 t.iterations = iterations;
@@ -1238,11 +1284,15 @@ export async function runTask(transport, session, task, deps) {
             if (done && reply.steps.length === 0) {
                 const verdict = await gateOnChecks();
                 if (verdict === 'environment') {
+                    stopCode = 'environment';
                     return await finish('failed', shellProblemReason(environmentProblem), reply.summary, lastMarkdown);
                 }
                 if (verdict === 'give-up') {
                     if (noProgressReason)
                         return await finish('blocked', noProgressReason, reply.summary, lastMarkdown);
+                    // Every failing check was refused before it ran: a verdict on the checks, not on the work.
+                    if (lastOutcomes.some((o) => !o.passed) && lastOutcomes.every((o) => o.passed || o.refusedBeforeRunning))
+                        stopCode = 'invalid-check';
                     return await finish('failed', checksFailedReason(lastOutcomes), reply.summary, lastMarkdown);
                 }
                 if (verdict === 'accept') {
@@ -1382,6 +1432,7 @@ export async function runTask(transport, session, task, deps) {
             // Ended before the report is written and sent: there is nobody to send it to who could
             // do anything with it, and the reason on the task says what to install or set instead.
             if (environmentProblem) {
+                stopCode = 'environment';
                 return await finish('failed', shellProblemReason(environmentProblem), reply.summary, lastMarkdown);
             }
             /*
@@ -1390,7 +1441,7 @@ export async function runTask(transport, session, task, deps) {
              * and the chat is told in the same message.
              */
             if (scopeEnforced) {
-                const check = await enforceScope(repoDirOf(session), scope).catch((e) => ({
+                const check = await enforceScope(repoDirOf(session), scope, !!task.readOnly).catch((e) => ({
                     outside: [],
                     reverted: [],
                     failed: [{ path: '(the working tree)', why: e.message }],
@@ -1398,7 +1449,7 @@ export async function runTask(transport, session, task, deps) {
                 if (check.outside.length > 0 || check.failed.length > 0) {
                     sink.event('scope-reverted', { iteration: iterations, reverted: check.reverted, failed: check.failed }, `outside the task's scope, put back: ${check.reverted.join(', ') || '(none)'}` +
                         (check.failed.length > 0 ? `; could not be put back: ${check.failed.map((f) => f.path).join(', ')}` : ''), 'warn');
-                    runnerNotes.push(scopeMessage(check, scope));
+                    runnerNotes.push(scopeMessage(check, scope, !!task.readOnly));
                     stats.scopeReverts += check.reverted.length;
                     await setTask((t) => {
                         t.scopeReverted = [...new Set([...(t.scopeReverted ?? []), ...check.reverted])];
@@ -1429,6 +1480,7 @@ export async function runTask(transport, session, task, deps) {
             const stuck = progress.afterRound(await treeNow(), results);
             if (stuck) {
                 stats.stoppedFor = 'no-progress';
+                stopCode = 'no-progress';
                 sink.event('no-progress', { kind: 'rounds', iteration: iterations }, stuck, 'warn');
                 return await finish('blocked', stuck, reply.summary, lastMarkdown);
             }
@@ -1529,11 +1581,15 @@ export async function runTask(transport, session, task, deps) {
             if (done) {
                 const verdict = await gateOnChecks();
                 if (verdict === 'environment') {
+                    stopCode = 'environment';
                     return await finish('failed', shellProblemReason(environmentProblem), reply.summary, lastMarkdown);
                 }
                 if (verdict === 'give-up') {
                     if (noProgressReason)
                         return await finish('blocked', noProgressReason, reply.summary, lastMarkdown);
+                    // Every failing check was refused before it ran: a verdict on the checks, not on the work.
+                    if (lastOutcomes.some((o) => !o.passed) && lastOutcomes.every((o) => o.passed || o.refusedBeforeRunning))
+                        stopCode = 'invalid-check';
                     return await finish('failed', checksFailedReason(lastOutcomes), reply.summary, lastMarkdown);
                 }
                 if (verdict === 'accept') {

package/dist/src/plan/schema.js

@@ -432,7 +432,7 @@ export function checkPlan(text) {
     if (!parsed.success) {
         return { ok: false, warnings, issues: parsed.error.issues.map((i) => ({ path: pathOf(i.path), message: i.message })) };
     }
-    const weak = weakCheckIssues(parsed.data);
+    const weak = [...weakCheckIssues(parsed.data), ...contradictionIssues(parsed.data)];
     if (weak.length)
         return { ok: false, warnings, issues: weak };
     return {
@@ -503,6 +503,26 @@ function weakCheckIssues(plan) {
     });
     return out;
 }
+/**
+ * A task whose own flags contradict each other: read-only (change nothing) and scoped (change
+ * these). Refused at import, where the chat that wrote it can still be asked which it meant; the
+ * runner refuses it again before starting (orchestrator/contract.ts) for a task edited since.
+ */
+function contradictionIssues(plan) {
+    const out = [];
+    plan.sessions.forEach((s, i) => {
+        s.tasks.forEach((t, j) => {
+            if (!t.readOnly || t.scope.length === 0)
+                return;
+            out.push({
+                path: `sessions[${i}].tasks[${j}]`,
+                message: `"${t.title}" is "readOnly": true, which allows no change, and has a "scope" (${t.scope.join(', ')}), which allows changes there. ` +
+                    'An audit that writes a report is not read-only: drop "readOnly" and scope it to the report. One that writes nothing: drop "scope".',
+            });
+        });
+    });
+    return out;
+}
 /** The issues as a block the user can hand back to the chat model without editing it. */
 export function describeIssues(issues) {
     return issues.map((i) => (i.path ? `- ${i.path}: ${i.message}` : `- ${i.message}`)).join('\n');

package/dist/src/plan/systemGuide.js

@@ -1437,6 +1437,22 @@ export const SYSTEM_GUIDE = [
                         doesEn: 'On a task that has already run: stores the edit and queues it again; the earlier attempt is kept. On a done task the new attempt builds on its work. It does not start it.',
                         doesBg: 'При вече изпълнена задача: записва промяната и я връща в опашката; предишният опит се пази. При готова задача новият опит стъпва върху свършеното. Не я пуска.',
                     },
+                    {
+                        key: 'task.readOnlyEdit',
+                        kind: 'checkbox',
+                        en: 'Read-only: this task must not change any file',
+                        bg: 'Само за четене: задачата не бива да променя нито един файл',
+                        doesEn: 'Also in the new-prompt dialog of the register. For an audit: every change a round makes is put back.',
+                        doesBg: 'Има го и в диалога за нов prompt в регистъра. За одит: всяка промяна от кръг се връща.',
+                    },
+                    {
+                        key: 'task.scopeEdit',
+                        kind: 'field',
+                        en: 'Files this task may change',
+                        bg: 'Файлове, които задачата може да променя',
+                        doesEn: 'One path or pattern per line; changes elsewhere are put back. Also in the new-prompt dialog, which lists the old checks to keep or drop.',
+                        doesBg: 'По един път или шаблон на ред; промени другаде се връщат. Има го и в диалога за нов prompt, който изброява старите проверки за запазване или махане.',
+                    },
                     {
                         key: 'task.branch',
                         kind: 'field',

package/dist/src/protocol/parser.js

@@ -60,8 +60,83 @@ export function stripCitations(text) {
         return undefined;
     return text.replace(/\s*【[^】]*】/g, '').replace(/[ 	]+$/gm, '').trim();
 }
+/*
+ * Prose that arrived in another shape.
+ *
+ * `tried`, `needed`, `notes` and `summary` are sentences for a person to read; nothing in them is
+ * run. A chat that writes `tried` as a list of objects — `{"approach": "…", "result": "…"}` — has
+ * said exactly what was asked, in a shape the schema did not expect, and refusing the whole reply
+ * for it cost a format round each time and, three in a row, the task: it ended "failed" with the
+ * work done and its results already recorded. So these fields are read as text whatever shape they
+ * come in, and the reading is reported. The fields that are acted on — `status`, `steps` and
+ * everything in them — are never coerced: a step the runner would have to guess at is not run.
+ */
+const PROSE_KEYS = ['approach', 'what', 'tried', 'attempt', 'action', 'description', 'text', 'summary', 'detail', 'result', 'outcome', 'why', 'reason', 'needed'];
+function proseOf(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value))
+        return value.map(proseOf).filter((x) => x.trim()).join('\n');
+    if (typeof value === 'object') {
+        const record = value;
+        const named = PROSE_KEYS.filter((k) => typeof record[k] === 'string' && record[k].trim()).map((k) => record[k]);
+        if (named.length > 0)
+            return named.join(' — ');
+        const strings = Object.values(record).filter((v) => typeof v === 'string' && v.trim() !== '');
+        return strings.length > 0 ? strings.join(' — ') : JSON.stringify(value);
+    }
+    return String(value);
+}
+export function normaliseProse(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return { value, coerced: [] };
+    const out = { ...value };
+    const coerced = [];
+    for (const key of ['notes', 'summary', 'needed']) {
+        if (key in out && out[key] !== undefined && typeof out[key] !== 'string') {
+            out[key] = proseOf(out[key]);
+            coerced.push(key);
+        }
+    }
+    if ('tried' in out && out.tried !== undefined) {
+        const tried = out.tried;
+        if (typeof tried === 'string') {
+            out.tried = tried.trim() ? [tried] : [];
+            coerced.push('tried');
+        }
+        else if (Array.isArray(tried) && tried.some((t) => typeof t !== 'string')) {
+            out.tried = tried.map(proseOf).filter((t) => t.trim() !== '');
+            tried.forEach((t, i) => {
+                if (typeof t !== 'string')
+                    coerced.push(`tried.${i}`);
+            });
+        }
+    }
+    return { value: out, coerced };
+}
+/** What each field must look like, said in the message that asks for a reformatted reply. */
+const FIELD_SHAPES = [
+    [/^status$/, '"status" is one of "continue", "done", "blocked"'],
+    [/^steps(\.|$)/, '"steps" is a list of {"id": 1, "type": "command", "cmd": "the command"} ("shell", "expect", "timeoutSec" optional)'],
+    [/^tried(\.|$)/, '"tried" is a list of plain strings, one sentence per approach'],
+    [/^deviations(\.|$)/, '"deviations" is a list of {"instruction": "…", "did": "…", "why": "…"} with plain strings'],
+    [/^disputed(\.|$)/, '"disputed" is a list of {"finding": "…", "why": "…", "evidence": "…"} with plain strings'],
+    [/^(summary|notes|needed)$/, '"summary", "notes" and "needed" are plain strings'],
+];
+const FORMAT_EXAMPLE = [
+    '```json',
+    '{"status": "continue", "notes": "what this round does", "steps": [{"id": 1, "type": "command", "cmd": "npm test"}]}',
+    '```',
+    'or, to end: {"status": "done", "summary": "several sentences on what was done and what it shows"}',
+    'or {"status": "blocked", "summary": "…", "tried": ["first approach", "second approach"], "needed": "what would unblock it"}',
+].join('\n');
 export function parseReply(markdown, opts) {
     const candidates = findJsonCandidates(markdown);
+    const paths = new Set();
     if (candidates.length === 0) {
         return {
             ok: false,
@@ -80,9 +155,12 @@ export function parseReply(markdown, opts) {
                 errors.push(`JSON.parse failed: ${e.message}`);
                 continue;
             }
-            const result = ReplySchema.safeParse(value);
+            const prose = normaliseProse(value);
+            const result = ReplySchema.safeParse(prose.value);
             if (!result.success) {
                 errors.push(result.error.issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`).join('; '));
+                for (const i of result.error.issues)
+                    paths.add(i.path.join('.') || '(root)');
                 continue;
             }
             const reply = result.data;
@@ -106,6 +184,7 @@ export function parseReply(markdown, opts) {
                 done: reply.status === 'done' || (markerHit && hasSummary && !blocked),
                 blocked,
                 json: text.trim(),
+                ...(prose.coerced.length > 0 ? { coerced: prose.coerced } : {}),
             };
         }
     }
@@ -113,6 +192,7 @@ export function parseReply(markdown, opts) {
         ok: false,
         reason: 'invalid-json',
         detail: errors.slice(0, 4).join(' | '),
+        ...(paths.size > 0 ? { paths: [...paths] } : {}),
     };
 }
 /**
@@ -162,15 +242,28 @@ export function parseReview(markdown, opts) {
     return { ok: false, reason: 'invalid-json', detail: errors.slice(0, 4).join(' | ') };
 }
 /** The message sent back when a reply did not validate. Names the problem, nothing else. */
+/**
+ * The message that asks for the same answer again, in the format.
+ *
+ * It names each rejected field with the shape it must have, gives a valid example, and says what
+ * did not happen: nothing from the rejected reply was run, so the results of the steps before it
+ * stand and the answer only needs reformatting. Without that last part a chat told "invalid" tends
+ * to start the round again, or to keep the same shape and change the wording, and the rounds run out.
+ */
 export function formatErrorMessage(fail, attempt, maxAttempts) {
+    const shapes = [...new Set((fail.paths ?? []).flatMap((p) => FIELD_SHAPES.filter(([re]) => re.test(p)).map(([, s]) => s)))];
     return [
-        `Your last reply did not match the required format (attempt ${attempt} of ${maxAttempts}).`,
+        `Your last reply did not match the required format (format retry ${attempt} of ${maxAttempts}).`,
         fail.reason === 'no-json-block'
             ? 'There was no fenced json code block in it.'
             : `The json block did not validate: ${fail.detail}`,
-        'Resend the same answer as exactly one fenced code block tagged json, with the fields',
-        'status, steps and notes, and nothing else tagged json in the reply.',
-    ].join(' ');
+        shapes.length > 0 ? `What those fields must be: ${shapes.join('; ')}.` : '',
+        'Only the format is wrong. Nothing from that reply was run, and the results of the steps before it stand.',
+        'Send the same answer again, reformatted, as exactly one fenced code block tagged json — do not start over and do not change what it asks for. For example:',
+        FORMAT_EXAMPLE,
+    ]
+        .filter(Boolean)
+        .join('\n');
 }
 /**
  * Spots a command that arrived damaged rather than badly written.

package/dist/src/session/exports.js

@@ -399,6 +399,7 @@ async function domainTask(session, task, runsDir) {
             scope: task.scope ?? [],
             scopeReverted: task.scopeReverted ?? [],
             handoff: task.handoff ?? null,
+            stopCode: task.stopCode ?? null,
             prompt: p.prompt,
             expected: p.expected,
             level2: task.level2,

package/dist/src/session/handoff.js

@@ -29,7 +29,7 @@ export function composeHandoff(task, notRun = []) {
     if ((vcs.suspicious?.length ?? 0) > 0 || (vcs.foreignCommits?.length ?? 0) > 0)
         manual.push('look at the committed files and commits listed above');
     return {
-        outcome: { status: task.status, ...(task.reason ? { reason: task.reason } : {}) },
+        outcome: { status: task.status, ...(task.reason ? { reason: task.reason } : {}), ...(task.stopCode ? { stopCode: task.stopCode } : {}) },
         changedFiles: (vcs.files ?? []).map((f) => ({ path: f.path, added: f.added, removed: f.removed })),
         validation: (task.checkResults ?? []).map((c) => ({ name: c.name, passed: c.passed })),
         ...(task.review ? { review: { verdict: task.review.verdict, open: openFindings.length } } : {}),

package/dist/src/session/store.js

@@ -42,6 +42,47 @@ export const DEFAULT_MIRROR = {
     respectGitignore: true,
     includeEnvFiles: false,
 };
+/**
+ * Applies an edit to a task: the one place the rule about a new intent lives.
+ *
+ * A task given a new prompt is a new question. The checks the reviews of its earlier attempts
+ * added were findings about the old question, and inheriting them gated the new one on work it
+ * no longer asks for: a maintenance task rewritten as an audit still had to pass "the build uses
+ * the new config", and went blocked on an artificial finding. So a changed prompt drops them, with
+ * the reason kept beside each, and they stay on the record. The plan's own checks are not guessed
+ * at: whoever writes the new prompt says which still apply (the edit form and the new-prompt
+ * dialog both show them), and `checks` in the patch is that answer. A re-run with the same prompt
+ * keeps everything, because it is the same question asked again.
+ */
+export function applyTaskPatch(t, patch) {
+    const newPrompt = patch.prompt !== undefined && patch.prompt.trim() !== '' && patch.prompt.trim() !== t.prompt.trim();
+    if (patch.title !== undefined)
+        t.title = patch.title.trim() || t.title;
+    if (patch.prompt !== undefined && patch.prompt.trim())
+        t.prompt = patch.prompt;
+    if (patch.level2 !== undefined)
+        t.level2 = patch.level2;
+    if (patch.vcsPlan !== undefined)
+        t.vcsPlan = tidyVcsPlan(patch.vcsPlan);
+    if (patch.checks !== undefined)
+        t.checks = patch.checks.filter((c) => c.name.trim() !== '');
+    if (patch.readOnly !== undefined) {
+        if (patch.readOnly)
+            t.readOnly = true;
+        else
+            delete t.readOnly;
+    }
+    if (patch.scope !== undefined) {
+        const scope = patch.scope.map((p) => p.trim()).filter(Boolean);
+        if (scope.length > 0)
+            t.scope = scope;
+        else
+            delete t.scope;
+    }
+    if (newPrompt && t.reviewChecks?.length) {
+        t.reviewChecks = t.reviewChecks.map((rc) => rc.state === 'dropped' ? rc : { ...rc, state: 'dropped', droppedBecause: 'the task was given a new prompt; this was a finding about the old one' });
+    }
+}
 export class SessionStore {
     defaultLevel1Path;
     dir;
@@ -358,22 +399,14 @@ export class SessionStore {
                     continuing: t.continuing,
                     buildsOn: t.buildsOn,
                     freshRetry: t.freshRetry,
+                    stopCode: t.stopCode,
                     scope: t.scope,
                     scopeReverted: t.scopeReverted,
                     vcs: t.vcs,
                 },
             ];
             // An edit is applied only after the old attempt has been put beyond its reach.
-            if (patch.title !== undefined)
-                t.title = patch.title.trim() || t.title;
-            if (patch.prompt !== undefined && patch.prompt.trim())
-                t.prompt = patch.prompt;
-            if (patch.level2 !== undefined)
-                t.level2 = patch.level2;
-            if (patch.vcsPlan !== undefined)
-                t.vcsPlan = tidyVcsPlan(patch.vcsPlan);
-            if (patch.checks !== undefined)
-                t.checks = patch.checks.filter((c) => c.name.trim() !== '');
+            applyTaskPatch(t, patch);
             t.attempt = (t.attempt ?? 1) + 1;
             t.status = 'queued';
             t.iterations = 0;
@@ -404,6 +437,7 @@ export class SessionStore {
             t.handoff = undefined;
             t.scopeReverted = undefined;
             t.freshRetry = undefined;
+            t.stopCode = undefined;
             // The branch of the finished attempt stays in the repository and stays on the record
             // above; the next attempt gets its own, cut from the same commit this one started at.
             t.vcs = undefined;

package/dist/src/transport/copilotTransport.js

@@ -750,12 +750,30 @@ Current URL: ${url}`);
             await this.closeMenu();
             return { ok: false, current: before, reason: `The picker does not offer "${name}" any more.` };
         }
+        /*
+         * Already the one in force: close the menu and say so, without clicking.
+         *
+         * The button cannot answer this on its own, because it shortens names — "GPT 5.6 Think deeper"
+         * reads "GPT 5.6 Think" — so the exact comparison above lets a chat that is already on the
+         * model through to here. The row's own mark (`aria-checked` and its kin) is the answer. The
+         * click it used to get did nothing in Copilot: the row already in force ignores it, the menu
+         * stayed open over the composer, and the run went on with the model list hanging on screen.
+         */
+        if (target.selected) {
+            await this.closeMenu();
+            this.emit('model-already-selected', { model: target.name, buttonShows: before });
+            return { ok: true, current: target.name };
+        }
         if (target.disabled) {
             await this.closeMenu();
             return { ok: false, current: before, reason: `"${name}" is shown but not available right now.` };
         }
         await this.clickMenuRow(target.name, inSubmenu);
         await this.p.waitForTimeout(1_000);
+        // Whatever the click did, the menu is not left open over the chat: a build that keeps it open
+        // after a choice, or a click that did not land, would otherwise leave it for the next message.
+        if ((await this.readMenuRows()).length > 0)
+            await this.closeMenu();
         const after = await this.currentModel();
         // The button shows the choice, so it is the check. It also **shortens** it: picking
         // "GPT 5.6 Quick response" leaves the button reading "GPT 5.6 Quick". So a shown value

package/dist/src/vcs/scope.js

@@ -65,12 +65,13 @@ export function inScope(path, scope) {
  * Puts back every change outside `scope`. Only for a repository whose tree was clean when the task
  * started, which is why the caller passes the repository only when version control is active.
  */
-export async function enforceScope(dir, scope) {
+export async function enforceScope(dir, scope, nothing = false) {
     const out = { outside: [], reverted: [], failed: [] };
-    if (scope.length === 0)
+    // An empty scope allows everything; `nothing` is the read-only task, which allows no change at all.
+    if (scope.length === 0 && !nothing)
         return out;
     const changed = await workingTreePaths(dir);
-    out.outside = changed.filter((p) => !inScope(p, scope));
+    out.outside = nothing ? changed : changed.filter((p) => !inScope(p, scope));
     const root = resolve(dir);
     for (const rel of out.outside) {
         const abs = resolve(join(dir, rel));
@@ -107,13 +108,15 @@ export async function enforceScope(dir, scope) {
     return out;
 }
 /** What the chat is told, in the message that carries the step results. */
-export function scopeMessage(check, scope) {
+export function scopeMessage(check, scope, readOnly = false) {
     const list = (paths) => paths.slice(0, 15).join(', ') + (paths.length > 15 ? `, and ${paths.length - 15} more` : '');
     const parts = [
-        `Outside this task's scope, so put back by the runner: ${list(check.reverted)}.`,
+        `${readOnly ? 'Changed by a read-only task' : "Outside this task's scope"}, so put back by the runner: ${list(check.reverted)}.`,
         check.failed.length > 0 ? `Could not be put back: ${check.failed.map((f) => `${f.path} (${f.why})`).join('; ')}.` : '',
-        `This task may change only: ${scope.join(', ')}. If the work truly needs a file outside that, do not work around it: ` +
-            'end with status "blocked", name the file in "needed" and say why.',
+        readOnly
+            ? 'This task is read-only: it may change no file at all. Read, run and report; put what you found in your summary.'
+            : `This task may change only: ${scope.join(', ')}. If the work truly needs a file outside that, do not work around it: ` +
+                'end with status "blocked", name the file in "needed" and say why.',
     ];
     return parts.filter(Boolean).join(' ');
 }