@agilemonster/mcp-server 1.0.23 → 1.0.24

package/dist/server.js

@@ -13,6 +13,7 @@ import { knownSecrets, redactResult } from './redact.js';
 import { describeProfile, methodLabel, normalizeMethod, resolveDeployProfile, trustBoundRoute, } from './deploy-profile.js';
 import { addPendingVerification, getCardState, loadMemory, recordAttempt, removePendingVerification, setCardState, setExplicitProfile, } from './deploy-memory.js';
 import { checkCiOnce, describeFailureForHuman, ensureLocalGitExcludes, parseDeployDirective, runDeployment, } from './deploy-runner.js';
+import { baselineFor, buildAgentPrompt, changesSince, clearBaseline, engineLabelFor, markNewFilesForDiff, parseAgentReport, proseOf, resolveEngines, restoreWorkingTree, runEngine, } from './agent-engine.js';
 import { addWellKnownToolDirs, agileMonsterHome, configureLogger, ensureUserPath, errorMessage, exec, log, readJson, which, writeJsonAtomic, } from './runtime.js';
 export function createServer(client = new AgileMonsterClient()) {
     const server = new Server({
@@ -1217,7 +1218,7 @@ function recentGitActivity(projectPath) {
         maxCommits = Math.max(maxCommits, n);
     return { files, dirCommits, maxCommits };
 }
-export function collectProjectSourceFiles(projectPath, keywords) {
+export function collectProjectSourceFiles(projectPath, keywords, phrases = []) {
     const isFlutterProject = fs.existsSync(path.join(projectPath, 'pubspec.yaml'));
     const activity = recentGitActivity(projectPath);
     let docsText = '';
@@ -1297,6 +1298,11 @@ export function collectProjectSourceFiles(projectPath, keywords) {
                     if (kw.length >= 4 && contentLower.includes(kw))
                         c.score += 10;
                 }
+                // Text the requester quoted from the screen: the file that renders it is almost certainly the target
+                for (const phrase of phrases) {
+                    if (contentLower.includes(phrase))
+                        c.score += 60;
+                }
             }
         }
         catch { }
@@ -1783,6 +1789,543 @@ function frontendBuildDirs(projectPath, modifiedFiles) {
     }
     return dirs;
 }
+/** The part of a build log that names the problem, without colour codes. Falls back to the last lines. */
+export function buildErrorExcerpt(output, maxLines = 12, maxChars = 1200) {
+    const lines = output
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, '')
+        .split('\n')
+        .map((l) => l.trimEnd())
+        .filter((l) => l.trim() !== '');
+    const at = lines.findIndex((l) => /(failed to compile|type error|error TS\d+|syntax ?error|module not found|cannot find|^\s*error\b|\berror:)/i.test(l));
+    const picked = at >= 0 ? lines.slice(Math.max(0, at - 1), at - 1 + maxLines) : lines.slice(-maxLines);
+    return picked.join('\n').slice(0, maxChars) || '(the build printed nothing)';
+}
+/** Pre-submit build gate: build the package that owns each changed front-end file (works for any monorepo layout). */
+async function runBuildGate(projectPath, files) {
+    for (const dir of frontendBuildDirs(projectPath, files)) {
+        const buildCmd = fs.existsSync(path.join(dir, 'pnpm-lock.yaml')) ? 'pnpm' : 'npm';
+        const res = await exec(buildCmd, ['run', 'build'], { cwd: dir, timeoutMs: 6 * 60 * 1000 });
+        if (res.timedOut) {
+            // A slow build is not a compile error: do not throw the work away over it
+            return { ok: true, note: `The build in \`${path.relative(projectPath, dir) || '.'}\` did not finish within 6 minutes, so it was not verified locally.` };
+        }
+        if (!res.ok) {
+            return { ok: false, errorOutput: `${res.stdout}\n${res.stderr}`.trim().slice(-8000) };
+        }
+    }
+    return { ok: true };
+}
+function brokenBaselineNote(errorOutput) {
+    return `⚠️ This project's build already fails on this machine without my change, so the change could not be build-verified here:\n\`\`\`\n${buildErrorExcerpt(errorOutput, 6, 500)}\n\`\`\``;
+}
+/** Why this card ran on the built-in pipeline, and the one thing that would put a real agent on the next one. */
+function builtInLimitsNote(run) {
+    const native = engineLabelFor(run.provider);
+    const fix = run.engineNotes.length > 0
+        ? run.engineNotes.map((n) => `- ${n}`).join('\n')
+        : `- No agent command line tool was found on this machine. Install ${native ? `${native}'s` : "Cursor's or Claude Code's"} CLI and sign in once.`;
+    return `This card ran on Agile Monster's built-in engine, which edits a handful of files in one pass and cannot explore the project or debug a build the way ${native || 'your coding agent'} does in the IDE. To have cards worked by the real agent:\n${fix}`;
+}
+/**
+ * The card's thread as the agent should read it: what the requester wrote, and the questions and results of
+ * earlier attempts. Status chatter is dropped. So is anything written by someone other than the person this
+ * machine belongs to: a comment is an instruction to an agent that can run commands here.
+ */
+async function cardConversation(client, card, ownerId) {
+    let comments = [];
+    try {
+        comments = await client.listComments(card.id);
+    }
+    catch {
+        return [];
+    }
+    const turns = [];
+    for (const c of Array.isArray(comments) ? comments : []) {
+        const text = (c.text || '').trim();
+        if (!text)
+            continue;
+        const fromAgent = (c.author_kind || 'member').toLowerCase() === 'agent' || /^(🤖|🛠️|✅|🚀|🔄|🛡️|🚨|⚠️|❓|⏳|📦|📤|💓)/u.test(text);
+        if (fromAgent) {
+            // Questions and review summaries are context; "claimed", "selected files", heartbeats are noise
+            if (!/^(❓|✅|⚠️ \*\*\[Agent Needs Input\]\*\*)/u.test(text))
+                continue;
+            turns.push({ who: 'agent', text: text.slice(0, 1500) });
+        }
+        else {
+            if (ownerId && c.user_id && c.user_id !== ownerId)
+                continue;
+            turns.push({ who: 'requester', text: text.slice(0, 3000) });
+        }
+    }
+    return turns.slice(-12);
+}
+/** Exact phrases the requester put in quotes ("Recently active projects"): the strongest pointer to the right file. */
+export function quotedPhrases(text) {
+    const out = new Set();
+    for (const m of text.matchAll(/["“”'‘’`]([^"“”'‘’`\n]{4,80})["“”'‘’`]/g)) {
+        const phrase = m[1].trim().toLowerCase();
+        if (phrase.split(/\s+/).length >= 2)
+            out.add(phrase);
+    }
+    return Array.from(out).slice(0, 12);
+}
+/**
+ * Hand the card to a real coding agent (Cursor, Claude Code, Codex — whichever this machine can run) and
+ * report what it changed. 'unavailable' means no agent could take it and the built-in pipeline should;
+ * 'handled' means the card went back to the human with a specific question or an honest failure report.
+ */
+async function produceChangeWithAgent(run) {
+    const { client, card, projectPath, provider, workerLabel, lockFile, carryOverFiles } = run;
+    const { engines, notes } = await resolveEngines(provider);
+    run.engineNotes.push(...notes);
+    if (engines.length === 0)
+        return 'unavailable';
+    // The agent gets a shell. Like a deploy command, what runs on this machine is for its owner to decide:
+    // only cards its owner wrote are handed over (and only the owner's replies were kept in the conversation).
+    if (!run.ownerId || !card.created_by || card.created_by !== run.ownerId) {
+        run.engineNotes.push(card.created_by
+            ? 'This card was written by another member of the board. An agent that can run commands on this machine only works cards its owner created.'
+            : 'The Agile Monster server did not say who created this card (it predates that field), so the agent on this machine was not started for it.');
+        log.info('agent.skipped', { card: card.id, reason: card.created_by ? 'card_not_from_owner' : 'author_unknown' });
+        return 'unavailable';
+    }
+    const started = await baselineFor(card.id, projectPath);
+    if (!started) {
+        run.engineNotes.push('The project folder is not a Git repository, so an agent\'s changes could not be tracked.');
+        return 'unavailable';
+    }
+    const baseline = started.snapshot;
+    const revert = async (files) => {
+        if (files.length > 0)
+            await restoreWorkingTree(projectPath, baseline, files);
+        clearBaseline(card.id);
+        return files.length > 0;
+    };
+    run.rollback.fn = async () => revert((await changesSince(projectPath, baseline)).changed);
+    const backToHuman = async (question, summary, files) => {
+        run.rollback.fn = null;
+        removeTaskLock(lockFile);
+        appendIdeActivityLog(projectPath, {
+            cardId: card.id,
+            cardTitle: card.title,
+            agentName: workerLabel,
+            model: card.agent_model || 'auto',
+            status: 'waiting_for_input',
+            summary,
+            files,
+        });
+        await client.askQuestion(card.id, provider, question);
+        return 'handled';
+    };
+    const prompt = buildAgentPrompt({
+        title: card.title || '',
+        description: card.description || '',
+        projectPath,
+        boardName: card.board_name,
+        conversation: run.conversation,
+        developerFiles: Array.from(baseline.entries.keys()).filter((f) => !carryOverFiles.includes(f)),
+        earlierFiles: carryOverFiles,
+        earlierSummary: run.earlierSummary,
+    });
+    const model = card.agent_model && card.agent_model !== 'auto' ? card.agent_model : null;
+    // 1. Run the first agent that actually starts. One that is logged out or crashes on launch touches nothing.
+    let engine = engines[0];
+    let result = null;
+    for (const candidate of engines) {
+        await client.addProgress(card.id, provider, `Autonomous background runner claimed task in \`${projectPath}\` and moved card to **In Progress**. **${candidate.label}** is working on it in the project folder — reading, searching, editing and building, as it would in the IDE.`);
+        log.info('agent.start', { card: card.id, engine: candidate.id, project: projectPath });
+        const attempt = await runEngine(candidate, { prompt, projectPath, model });
+        log.info('agent.end', { card: card.id, engine: candidate.id, ok: attempt.ok, seconds: Math.round(attempt.durationMs / 1000), failure: attempt.failure });
+        if (!attempt.ok && (await changesSince(projectPath, baseline)).changed.length === 0) {
+            run.engineNotes.push(`${candidate.label} could not run: ${attempt.failure || 'it exited without a result'}`);
+            continue;
+        }
+        engine = candidate;
+        result = attempt;
+        break;
+    }
+    if (!result) {
+        run.rollback.fn = null;
+        clearBaseline(card.id);
+        return 'unavailable';
+    }
+    if (result.costUsd && result.costUsd > 0) {
+        try {
+            await client.recordSpend(card.id, provider, 0, result.costUsd, `${engine.label} headless run`);
+        }
+        catch { }
+    }
+    let change = await changesSince(projectPath, baseline);
+    if (change.pushedCommit) {
+        clearBaseline(card.id);
+        return backToHuman(`${engine.label} committed and pushed its work itself (\`${change.pushedCommit.slice(0, 10)}\`) instead of leaving that to me, so I did not run the usual build check or deployment for this card.\n\nPlease look at that commit. Reply here if it needs changes.`, `${engine.label} pushed ${change.pushedCommit.slice(0, 10)} on its own`, change.changed);
+    }
+    // Never ship the developer's own half-finished work under this card's name
+    const foreign = change.overlapping.filter((f) => !carryOverFiles.includes(f));
+    if (foreign.length > 0) {
+        await revert(change.changed);
+        return backToHuman(`I need to change ${foreign.map((f) => `\`${f}\``).join(', ')}, but ${foreign.length === 1 ? 'that file has' : 'those files have'} uncommitted changes in \`${projectPath}\` that are not mine. Committing my edit would also commit that unfinished work, so I stopped and put everything back.\n\n${started.interrupted
+            ? 'An earlier run of this card was interrupted before it finished, so these may be its leftovers rather than your work. If you did not make them, discard them (`git checkout -- <file>`); otherwise commit or stash them. Then reply here and I will continue.'
+            : 'Commit or stash those changes, then reply here and I will continue.'}`, `Stopped: ${foreign.join(', ')} had uncommitted changes`, foreign);
+    }
+    if (!result.ok) {
+        await revert(change.changed);
+        return backToHuman(`${engine.label} worked on this for ${Math.max(1, Math.round(result.durationMs / 60000))} minute(s) but did not finish: ${result.failure || 'it stopped without a result'}.\n\nI put the files back the way they were. Reply here to have it try again — if the card is large, splitting it into smaller cards helps.`, `${engine.label} did not finish: ${result.failure || 'no result'}`, []);
+    }
+    let report = parseAgentReport(result.text);
+    if (report.status === 'blocked' || change.changed.length === 0) {
+        await revert(change.changed);
+        const said = report.question || report.summary || proseOf(result.text);
+        return backToHuman(report.status === 'blocked' && report.question
+            ? report.question
+            : `${engine.label} finished without changing any files.${said ? `\n\n${said}` : ''}\n\nIf something is still missing, reply here with what you expected to change.`, `Needs input: ${said.slice(0, 400)}`, []);
+    }
+    // 2. The runner's own build gate. The agent built it too, so a failure here is usually this machine's
+    // environment — check that before sending the agent after an error that was never its own.
+    let gate = await runBuildGate(projectPath, change.changed);
+    if (!gate.ok) {
+        const mine = new Map();
+        for (const rel of change.changed) {
+            try {
+                mine.set(rel, fs.readFileSync(path.join(projectPath, rel)));
+            }
+            catch {
+                mine.set(rel, null);
+            }
+        }
+        await restoreWorkingTree(projectPath, baseline, change.changed);
+        const pristine = await runBuildGate(projectPath, change.changed);
+        for (const [rel, content] of mine) {
+            const abs = path.join(projectPath, rel);
+            if (content === null) {
+                fs.rmSync(abs, { force: true });
+            }
+            else {
+                fs.mkdirSync(path.dirname(abs), { recursive: true });
+                fs.writeFileSync(abs, content);
+            }
+        }
+        if (!pristine.ok) {
+            gate = { ok: true, note: brokenBaselineNote(pristine.errorOutput || '') };
+        }
+        else {
+            await client.addProgress(card.id, provider, `The build failed after the change. Sending the error back to ${engine.label} to fix.`);
+            const repair = await runEngine(engine, {
+                prompt: `The Agile Monster runner built the project after your change and the build failed:\n\n${buildErrorExcerpt(gate.errorOutput || '', 60, 5000)}\n\nYour changes are still in the working tree. Fix the build, run it yourself to confirm, and keep to the same rules as before (no commits, no Agile Monster tools). End with the same closing JSON object.\n\nFor reference, the original brief:\n\n${prompt}`,
+                projectPath,
+                model,
+                resumeSessionId: result.sessionId,
+            });
+            change = await changesSince(projectPath, baseline);
+            const repairedReport = parseAgentReport(repair.text);
+            if (repairedReport.status === 'done' && repairedReport.summary)
+                report = repairedReport;
+            gate = change.changed.length > 0 ? await runBuildGate(projectPath, change.changed) : gate;
+            const stillForeign = change.overlapping.filter((f) => !carryOverFiles.includes(f));
+            if (!gate.ok || change.changed.length === 0 || stillForeign.length > 0) {
+                await revert(change.changed);
+                return backToHuman(`${engine.label} made the change, but the project did not build with it, and its attempt to fix that did not get the build green. I reverted everything rather than ship a broken build.\n\n\`\`\`\n${buildErrorExcerpt(gate.errorOutput || '')}\n\`\`\`\n\nYour description was clear — nothing more is needed from you on that. Reply here to have it try again.`, `Reverted: the build failed after ${engine.label}'s change`, []);
+            }
+        }
+    }
+    await markNewFilesForDiff(projectPath, change.changed);
+    return {
+        modifiedFiles: change.changed,
+        summary: report.summary || proseOf(result.text, 700),
+        verificationSteps: report.verificationSteps.length > 0 ? report.verificationSteps : undefined,
+        buildNote: gate.note,
+        inspectedFiles: [],
+        engine: engine.label,
+    };
+}
+/**
+ * The built-in pipeline: rank the project's files, let the server-side model pick a handful, and apply the
+ * search/replace edits it returns. It cannot explore or run anything, so it is the fallback for machines
+ * without an agent CLI. Returns null when the card was handed back to the human.
+ */
+async function produceChangeBuiltIn(run) {
+    const { client, card, projectPath, provider, workerLabel, lockFile, profile, carryOverFiles, originalContents } = run;
+    await client.addProgress(card.id, provider, `Autonomous background runner claimed task in \`${projectPath}\` and moved card to **In Progress**. Scanning repository files...` +
+        (run.engineNotes.length > 0 ? `\n\nUsing the built-in engine for this card:\n${run.engineNotes.map((n) => `- ${n}`).join('\n')}` : ''));
+    // 2. Build keyword list from the card and what the requester wrote on it, and collect project source files.
+    // Their replies count: "the Recently active projects table on the Operations page" is where the answer is.
+    const requestText = [card.title || '', card.description || '', ...run.conversation.filter((t) => t.who === 'requester').map((t) => t.text)].join(' ');
+    const rawText = requestText.toLowerCase();
+    const stopWords = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'need', 'make', 'user', 'use', 'into', 'when', 'through']);
+    const keywords = Array.from(new Set(rawText
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length >= 3 && !stopWords.has(w))));
+    const fileIndex = collectProjectSourceFiles(projectPath, keywords, quotedPhrases(requestText));
+    if (fileIndex.length === 0) {
+        removeTaskLock(lockFile);
+        await client.askQuestion(card.id, provider, `I could not find any source files to work on in \`${projectPath}\`. Is this the right folder for the "${card.board_name || 'this'}" board? If not, connect the correct project folder in the board's AI Agents settings and reply here.`);
+        return null;
+    }
+    // 3. Ask Agile Monster Autonomous Step to pick the 1-6 most relevant files
+    const projectContext = readProjectInstructionsContext(projectPath, profile);
+    const selectionRes = await client.autonomousStep({
+        card_id: card.id,
+        action: 'select_files',
+        file_index: fileIndex,
+        project_context: projectContext,
+    });
+    // The model may only choose from the files it was offered: a path it made up (../../.ssh/…, .env) is dropped
+    const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || [])
+        .filter((f) => typeof f === 'string' && fileIndex.includes(f))
+        .slice(0, 6);
+    if (selectedFiles.length === 0) {
+        selectedFiles.push(...fileIndex.slice(0, 4));
+    }
+    // Automatically include project type definition files (e.g. types.ts,frontend/src/lib/types.ts) so the model knows exact schemas
+    for (const candidateTypeFile of [
+        'frontend/src/lib/types.ts',
+        'src/lib/types.ts',
+        'src/types.ts',
+        'src/types/index.ts',
+        'frontend/src/types.ts',
+    ]) {
+        if (fileIndex.includes(candidateTypeFile) &&
+            !selectedFiles.includes(candidateTypeFile) &&
+            selectedFiles.length < 7) {
+            selectedFiles.push(candidateTypeFile);
+        }
+    }
+    const filesPayload = {};
+    for (const rel of selectedFiles) {
+        const full = path.join(projectPath, rel);
+        if (fs.existsSync(full)) {
+            try {
+                const raw = fs.readFileSync(full);
+                // A file that is not valid UTF-8 would be silently corrupted by a text round-trip: leave it alone
+                if (isUtf8(raw))
+                    filesPayload[rel] = raw.toString('utf8');
+            }
+            catch { }
+        }
+    }
+    if (Object.keys(filesPayload).length === 0) {
+        removeTaskLock(lockFile);
+        await client.askQuestion(card.id, provider, 'I could not read the files I selected for this task. Could you point me at the page, screen or file this should change?');
+        return null;
+    }
+    await client.addProgress(card.id, provider, `Selected target files for implementation: ${Object.keys(filesPayload)
+        .map((f) => `\`${f}\``)
+        .join(', ')}. Generating code changes...`);
+    // 4. Generate surgical code edits
+    let editsRes = await client.autonomousStep({
+        card_id: card.id,
+        action: 'generate_edits',
+        files: filesPayload,
+        project_context: projectContext,
+    });
+    // Gate A: Strict truth — if the model is not confident / cannot find the target, ask the human instead of guessing
+    if (editsRes.needs_clarification && (editsRes.clarification_question || '').trim() !== '') {
+        removeTaskLock(lockFile);
+        appendIdeActivityLog(projectPath, {
+            cardId: card.id,
+            cardTitle: card.title,
+            agentName: workerLabel,
+            model: card.agent_model || 'auto',
+            status: 'waiting_for_input',
+            summary: `Needs clarification: ${editsRes.clarification_question}`,
+            files: Object.keys(filesPayload),
+        });
+        await client.askQuestion(card.id, provider, (editsRes.clarification_question || '').trim());
+        return null;
+    }
+    // Only the files that were actually sent to the model may be edited (never .git/, never a path it invented)
+    const editableFiles = new Set(Object.keys(filesPayload));
+    const projectRoot = fs.realpathSync(projectPath);
+    /**
+     * Apply one set of edits. Returns the files changed and a reason for every edit that could not be applied.
+     * A set of edits is one coordinated change: the caller ships it only if ALL of it applied.
+     */
+    const applyEditsPass = async (editsList) => {
+        const modFiles = [];
+        const failed = [];
+        for (const edit of editsList) {
+            const relPath = (edit.file || edit.path || '').replace(/\\/g, '/').replace(/^\.\//, '');
+            if (!relPath || !edit.search || typeof edit.replace !== 'string') {
+                failed.push(`${relPath || '(no file)'}: the edit was incomplete`);
+                continue;
+            }
+            if (!editableFiles.has(relPath)) {
+                failed.push(`${relPath}: not one of the files provided`);
+                continue;
+            }
+            const fullPath = path.resolve(projectPath, relPath);
+            let realPath = '';
+            try {
+                realPath = fs.realpathSync(fullPath);
+            }
+            catch { }
+            if (!realPath || !(realPath === projectRoot || realPath.startsWith(projectRoot + path.sep))) {
+                failed.push(`${relPath}: outside the project`);
+                continue;
+            }
+            const currentContent = fs.readFileSync(fullPath, 'utf8');
+            if (!currentContent.includes(edit.search)) {
+                failed.push(`${relPath}: the \`search\` text was not found verbatim in the file`);
+                continue;
+            }
+            const updatedContent = currentContent.replace(edit.search, () => edit.replace);
+            if (updatedContent === currentContent)
+                continue; // nothing to do is not a failure
+            const countChar = (s, ch) => s.split(ch).length - 1;
+            const searchBraceDelta = countChar(edit.search, '{') - countChar(edit.search, '}');
+            const replaceBraceDelta = countChar(edit.replace, '{') - countChar(edit.replace, '}');
+            const searchParenDelta = countChar(edit.search, '(') - countChar(edit.search, ')');
+            const replaceParenDelta = countChar(edit.replace, '(') - countChar(edit.replace, ')');
+            if (searchBraceDelta !== replaceBraceDelta || searchParenDelta !== replaceParenDelta) {
+                failed.push(`${relPath}: the replacement would leave braces or parentheses unbalanced`);
+                continue;
+            }
+            if (!originalContents.has(fullPath))
+                originalContents.set(fullPath, currentContent);
+            fs.writeFileSync(fullPath, updatedContent, 'utf8');
+            journalEdits(card.id, projectPath, originalContents);
+            // Per-file syntax checks run without blocking the event loop (the worker heartbeat must keep ticking)
+            if (relPath.endsWith('.dart')) {
+                const lint = await exec('dart', ['analyze', fullPath], { cwd: projectPath, timeoutMs: 40000 });
+                if (!lint.ok && /\berror\s+[•-]/i.test(lint.stdout + lint.stderr)) {
+                    fs.writeFileSync(fullPath, currentContent, 'utf8');
+                    failed.push(`${relPath}: dart analyze reported an error after the edit: ${lint.tail.slice(0, 300)}`);
+                    continue;
+                }
+            }
+            else if (relPath.endsWith('.php')) {
+                const lint = await exec('php', ['-l', fullPath], { cwd: projectPath, timeoutMs: 15000 });
+                // exit code null = `php` is not installed here: that must not discard valid work
+                if (!lint.ok && lint.code !== null && !lint.timedOut) {
+                    fs.writeFileSync(fullPath, currentContent, 'utf8');
+                    failed.push(`${relPath}: PHP syntax error after the edit: ${lint.tail.slice(0, 300)}`);
+                    continue;
+                }
+            }
+            if (!modFiles.includes(relPath))
+                modFiles.push(relPath);
+        }
+        return { modFiles, failed };
+    };
+    const revertAll = () => {
+        for (const [fPath, orig] of originalContents.entries()) {
+            try {
+                fs.writeFileSync(fPath, orig, 'utf8');
+            }
+            catch { }
+        }
+        originalContents.clear();
+        clearEditJournal(card.id);
+    };
+    // Never build on top of the developer's own uncommitted work in the same file: a whole-file commit would
+    // ship their half-finished changes under this card's name.
+    const targetFiles = Array.from(new Set((editsRes.edits || []).map((e) => (e.file || e.path || '').replace(/\\/g, '/').replace(/^\.\//, '')).filter((f) => editableFiles.has(f))));
+    if (targetFiles.length > 0) {
+        const status = await exec('git', ['--literal-pathspecs', 'status', '--porcelain', '--', ...targetFiles], { cwd: projectPath, timeoutMs: 20000 });
+        const dirty = status.ok
+            ? status.stdout
+                .split('\n')
+                .filter((l) => l.trim() && !l.startsWith('??'))
+                .map((l) => l.slice(3).trim())
+                .filter((f) => !carryOverFiles.includes(f))
+            : [];
+        if (dirty.length > 0) {
+            removeTaskLock(lockFile);
+            await client.askQuestion(card.id, provider, `I need to change ${dirty.map((f) => `\`${f}\``).join(', ')}, but ${dirty.length === 1 ? 'that file has' : 'those files have'} uncommitted changes in \`${projectPath}\` that are not mine. Committing my edit would also commit that unfinished work, so I stopped.\n\nCommit or stash those changes, then reply here and I will continue.`);
+            return null;
+        }
+    }
+    let pass = await applyEditsPass(editsRes.edits || []);
+    if (pass.failed.length > 0) {
+        // Half of a coordinated change is worse than none: undo it and give the model one chance to correct itself
+        revertAll();
+        editsRes = await client.autonomousStep({
+            card_id: card.id,
+            action: 'generate_edits',
+            files: {
+                ...filesPayload,
+                '__EDITS_THAT_DID_NOT_APPLY__.txt': `Your previous edits were NOT applied because some of them could not be applied, and a partial change must never ship:\n${pass.failed.join('\n')}\nReturn the complete set of edits again. Every \`search\` must be copied verbatim from the current file contents, and only files listed in \`files\` may be edited.`,
+            },
+            project_context: projectContext,
+        });
+        pass = await applyEditsPass(editsRes.edits || []);
+        if (pass.failed.length > 0) {
+            revertAll();
+            pass = { modFiles: [], failed: pass.failed };
+        }
+    }
+    const modifiedFiles = pass.modFiles;
+    const applyFailures = pass.failed;
+    let buildCheck = await runBuildGate(projectPath, modifiedFiles);
+    if (!buildCheck.ok) {
+        const firstEdits = editsRes.edits || [];
+        const builtFiles = [...modifiedFiles];
+        revertAll();
+        modifiedFiles.length = 0;
+        // Is it this change, or does the project not build on this machine at all? Only the first is a reason to
+        // throw the work away — a build that was already red says nothing about the edit.
+        const pristine = await runBuildGate(projectPath, builtFiles);
+        if (!pristine.ok) {
+            const again = await applyEditsPass(firstEdits);
+            if (again.failed.length === 0) {
+                modifiedFiles.push(...again.modFiles);
+                buildCheck = { ok: true, note: brokenBaselineNote(pristine.errorOutput || '') };
+            }
+            else {
+                revertAll();
+                applyFailures.push(...again.failed);
+            }
+        }
+        else {
+            for (let attempt = 0; attempt < 2 && !buildCheck.ok; attempt++) {
+                editsRes = await client.autonomousStep({
+                    card_id: card.id,
+                    action: 'generate_edits',
+                    files: {
+                        ...filesPayload,
+                        '__COMPILER_ERROR_TO_FIX__.txt': `Your previous edits were reverted because the project no longer built:\n${buildErrorExcerpt(buildCheck.errorOutput || '', 40, 3500)}\nReturn the complete set of edits again with this fixed. Use only identifiers, props and fields that exist in the files provided.`,
+                    },
+                    project_context: projectContext,
+                });
+                const retryPass = await applyEditsPass(editsRes.edits || []);
+                if (retryPass.failed.length > 0) {
+                    revertAll();
+                    applyFailures.push(...retryPass.failed);
+                    break;
+                }
+                modifiedFiles.push(...retryPass.modFiles);
+                buildCheck = await runBuildGate(projectPath, modifiedFiles);
+                if (!buildCheck.ok) {
+                    revertAll();
+                    modifiedFiles.length = 0;
+                }
+            }
+        }
+    }
+    if (modifiedFiles.length === 0) {
+        removeTaskLock(lockFile);
+        revertAll();
+        // Say what actually went wrong. The requester already described the task (possibly twice): asking them
+        // "where should this appear?" again would be a question about my limits dressed up as one about theirs.
+        const reason = !buildCheck.ok && buildCheck.errorOutput
+            ? `The change I wrote did not build, so I reverted it. The build said:\n\`\`\`\n${buildErrorExcerpt(buildCheck.errorOutput)}\n\`\`\``
+            : applyFailures.length > 0
+                ? `The change I generated could not be applied cleanly, so nothing was modified:\n${applyFailures.slice(0, 4).map((f) => `- ${f}`).join('\n').slice(0, 700)}`
+                : 'The model returned no change for these files.';
+        await client.askQuestion(card.id, provider, `I could not finish this card. I worked in ${Object.keys(filesPayload)
+            .map((f) => `\`${f}\``)
+            .join(', ')}.\n\n${reason}\n\n${builtInLimitsNote(run)}\n\nYour description was clear — nothing more is needed from you on that. Reply here to have me try again.`);
+        return null;
+    }
+    return {
+        modifiedFiles,
+        summary: editsRes.summary || '',
+        verificationSteps: editsRes.verification_steps,
+        buildNote: buildCheck.note,
+        inspectedFiles: Object.keys(filesPayload),
+        engine: 'built-in',
+    };
+}
 export async function executeQueuedCardAutonomously(client, card, projectPath) {
     if (!projectPath || !fs.existsSync(projectPath))
         return false;
@@ -1820,6 +2363,8 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
     const workerLabel = card.agent_display_name || provider;
     // Original contents of every file this run touches, so an interrupted run never leaves half-applied edits behind
     const originalContents = new Map();
+    // The agent path cannot know its files up front: it registers how to put the tree back instead
+    const rollback = { fn: null };
     let editsHandedOff = false;
     log.info('card.start', { card: card.id, title: card.title, project: projectPath, provider });
     try {
@@ -1859,284 +2404,45 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             return await runRedeployOnlyCard(client, card, projectPath, provider, workerLabel, lockFile);
         }
         const profile = resolveDeployProfile(projectPath, { bound: boundProfileOf(card, await machineOwnerId(client)), memory: loadMemory(projectPath) });
-        await client.addProgress(card.id, provider, `Autonomous background runner claimed task in \`${projectPath}\` and moved card to **In Progress**. Scanning repository files...`);
-        // 2. Build keyword list from card title + description and collect project source files
-        const rawText = `${card.title || ''} ${card.description || ''}`.toLowerCase();
-        const stopWords = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'need', 'make', 'user', 'use', 'into', 'when', 'through']);
-        const keywords = Array.from(new Set(rawText
-            .split(/[^a-z0-9]+/)
-            .filter((w) => w.length >= 3 && !stopWords.has(w))));
-        const fileIndex = collectProjectSourceFiles(projectPath, keywords);
-        if (fileIndex.length === 0) {
-            removeTaskLock(lockFile);
-            await client.askQuestion(card.id, provider, `I could not find any source files to work on in \`${projectPath}\`. Is this the right folder for the "${card.board_name || 'this'}" board? If not, connect the correct project folder in the board's AI Agents settings and reply here.`);
-            return false;
-        }
-        // 3. Ask Agile Monster Autonomous Step to pick the 1-6 most relevant files
-        const projectContext = readProjectInstructionsContext(projectPath, profile);
-        const selectionRes = await client.autonomousStep({
-            card_id: card.id,
-            action: 'select_files',
-            file_index: fileIndex,
-            project_context: projectContext,
-        });
-        // The model may only choose from the files it was offered: a path it made up (../../.ssh/…, .env) is dropped
-        const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || [])
-            .filter((f) => typeof f === 'string' && fileIndex.includes(f))
-            .slice(0, 6);
-        if (selectedFiles.length === 0) {
-            selectedFiles.push(...fileIndex.slice(0, 4));
-        }
-        // Automatically include project type definition files (e.g. types.ts,frontend/src/lib/types.ts) so the model knows exact schemas
-        for (const candidateTypeFile of [
-            'frontend/src/lib/types.ts',
-            'src/lib/types.ts',
-            'src/types.ts',
-            'src/types/index.ts',
-            'frontend/src/types.ts',
-        ]) {
-            if (fileIndex.includes(candidateTypeFile) &&
-                !selectedFiles.includes(candidateTypeFile) &&
-                selectedFiles.length < 7) {
-                selectedFiles.push(candidateTypeFile);
-            }
-        }
-        const filesPayload = {};
-        for (const rel of selectedFiles) {
-            const full = path.join(projectPath, rel);
-            if (fs.existsSync(full)) {
-                try {
-                    const raw = fs.readFileSync(full);
-                    // A file that is not valid UTF-8 would be silently corrupted by a text round-trip: leave it alone
-                    if (isUtf8(raw))
-                        filesPayload[rel] = raw.toString('utf8');
-                }
-                catch { }
-            }
-        }
-        if (Object.keys(filesPayload).length === 0) {
-            removeTaskLock(lockFile);
-            await client.askQuestion(card.id, provider, 'I could not read the files I selected for this task. Could you point me at the page, screen or file this should change?');
-            return false;
-        }
-        await client.addProgress(card.id, provider, `Selected target files for implementation: ${Object.keys(filesPayload)
-            .map((f) => `\`${f}\``)
-            .join(', ')}. Generating code changes...`);
-        // 4. Generate surgical code edits
-        let editsRes = await client.autonomousStep({
-            card_id: card.id,
-            action: 'generate_edits',
-            files: filesPayload,
-            project_context: projectContext,
-        });
-        // Gate A: Strict truth — if the model is not confident / cannot find the target, ask the human instead of guessing
-        if (editsRes.needs_clarification && (editsRes.clarification_question || '').trim() !== '') {
-            removeTaskLock(lockFile);
-            appendIdeActivityLog(projectPath, {
-                cardId: card.id,
-                cardTitle: card.title,
-                agentName: workerLabel,
-                model: card.agent_model || 'auto',
-                status: 'waiting_for_input',
-                summary: `Needs clarification: ${editsRes.clarification_question}`,
-                files: Object.keys(filesPayload),
-            });
-            await client.askQuestion(card.id, provider, (editsRes.clarification_question || '').trim());
-            return false;
-        }
-        // Only the files that were actually sent to the model may be edited (never .git/, never a path it invented)
-        const editableFiles = new Set(Object.keys(filesPayload));
-        const projectRoot = fs.realpathSync(projectPath);
-        /**
-         * Apply one set of edits. Returns the files changed and a reason for every edit that could not be applied.
-         * A set of edits is one coordinated change: the caller ships it only if ALL of it applied.
-         */
-        const applyEditsPass = async (editsList) => {
-            const modFiles = [];
-            const failed = [];
-            for (const edit of editsList) {
-                const relPath = (edit.file || edit.path || '').replace(/\\/g, '/').replace(/^\.\//, '');
-                if (!relPath || !edit.search || typeof edit.replace !== 'string') {
-                    failed.push(`${relPath || '(no file)'}: the edit was incomplete`);
-                    continue;
-                }
-                if (!editableFiles.has(relPath)) {
-                    failed.push(`${relPath}: not one of the files provided`);
-                    continue;
-                }
-                const fullPath = path.resolve(projectPath, relPath);
-                let realPath = '';
-                try {
-                    realPath = fs.realpathSync(fullPath);
-                }
-                catch { }
-                if (!realPath || !(realPath === projectRoot || realPath.startsWith(projectRoot + path.sep))) {
-                    failed.push(`${relPath}: outside the project`);
-                    continue;
-                }
-                const currentContent = fs.readFileSync(fullPath, 'utf8');
-                if (!currentContent.includes(edit.search)) {
-                    failed.push(`${relPath}: the \`search\` text was not found verbatim in the file`);
-                    continue;
-                }
-                const updatedContent = currentContent.replace(edit.search, () => edit.replace);
-                if (updatedContent === currentContent)
-                    continue; // nothing to do is not a failure
-                const countChar = (s, ch) => s.split(ch).length - 1;
-                const searchBraceDelta = countChar(edit.search, '{') - countChar(edit.search, '}');
-                const replaceBraceDelta = countChar(edit.replace, '{') - countChar(edit.replace, '}');
-                const searchParenDelta = countChar(edit.search, '(') - countChar(edit.search, ')');
-                const replaceParenDelta = countChar(edit.replace, '(') - countChar(edit.replace, ')');
-                if (searchBraceDelta !== replaceBraceDelta || searchParenDelta !== replaceParenDelta) {
-                    failed.push(`${relPath}: the replacement would leave braces or parentheses unbalanced`);
-                    continue;
-                }
-                if (!originalContents.has(fullPath))
-                    originalContents.set(fullPath, currentContent);
-                fs.writeFileSync(fullPath, updatedContent, 'utf8');
-                journalEdits(card.id, projectPath, originalContents);
-                // Per-file syntax checks run without blocking the event loop (the worker heartbeat must keep ticking)
-                if (relPath.endsWith('.dart')) {
-                    const lint = await exec('dart', ['analyze', fullPath], { cwd: projectPath, timeoutMs: 40000 });
-                    if (!lint.ok && /\berror\s+[•-]/i.test(lint.stdout + lint.stderr)) {
-                        fs.writeFileSync(fullPath, currentContent, 'utf8');
-                        failed.push(`${relPath}: dart analyze reported an error after the edit: ${lint.tail.slice(0, 300)}`);
-                        continue;
-                    }
-                }
-                else if (relPath.endsWith('.php')) {
-                    const lint = await exec('php', ['-l', fullPath], { cwd: projectPath, timeoutMs: 15000 });
-                    // exit code null = `php` is not installed here: that must not discard valid work
-                    if (!lint.ok && lint.code !== null && !lint.timedOut) {
-                        fs.writeFileSync(fullPath, currentContent, 'utf8');
-                        failed.push(`${relPath}: PHP syntax error after the edit: ${lint.tail.slice(0, 300)}`);
-                        continue;
-                    }
-                }
-                if (!modFiles.includes(relPath))
-                    modFiles.push(relPath);
-            }
-            return { modFiles, failed };
-        };
-        const revertAll = () => {
-            for (const [fPath, orig] of originalContents.entries()) {
-                try {
-                    fs.writeFileSync(fPath, orig, 'utf8');
-                }
-                catch { }
-            }
-            originalContents.clear();
-            clearEditJournal(card.id);
-        };
-        // Never build on top of the developer's own uncommitted work in the same file: a whole-file commit would
-        // ship their half-finished changes under this card's name.
-        const targetFiles = Array.from(new Set((editsRes.edits || []).map((e) => (e.file || e.path || '').replace(/\\/g, '/').replace(/^\.\//, '')).filter((f) => editableFiles.has(f))));
-        if (targetFiles.length > 0) {
-            const status = await exec('git', ['--literal-pathspecs', 'status', '--porcelain', '--', ...targetFiles], { cwd: projectPath, timeoutMs: 20000 });
-            const dirty = status.ok
-                ? status.stdout
-                    .split('\n')
-                    .filter((l) => l.trim() && !l.startsWith('??'))
-                    .map((l) => l.slice(3).trim())
-                    .filter((f) => !carryOverFiles.includes(f))
-                : [];
-            if (dirty.length > 0) {
-                removeTaskLock(lockFile);
-                await client.askQuestion(card.id, provider, `I need to change ${dirty.map((f) => `\`${f}\``).join(', ')}, but ${dirty.length === 1 ? 'that file has' : 'those files have'} uncommitted changes in \`${projectPath}\` that are not mine. Committing my edit would also commit that unfinished work, so I stopped.\n\nCommit or stash those changes, then reply here and I will continue.`);
-                return false;
-            }
-        }
-        let pass = await applyEditsPass(editsRes.edits || []);
-        if (pass.failed.length > 0) {
-            // Half of a coordinated change is worse than none: undo it and give the model one chance to correct itself
-            revertAll();
-            editsRes = await client.autonomousStep({
-                card_id: card.id,
-                action: 'generate_edits',
-                files: {
-                    ...filesPayload,
-                    '__EDITS_THAT_DID_NOT_APPLY__.txt': `Your previous edits were NOT applied because some of them could not be applied, and a partial change must never ship:\n${pass.failed.join('\n')}\nReturn the complete set of edits again. Every \`search\` must be copied verbatim from the current file contents, and only files listed in \`files\` may be edited.`,
-                },
-                project_context: projectContext,
-            });
-            pass = await applyEditsPass(editsRes.edits || []);
-            if (pass.failed.length > 0) {
-                revertAll();
-                pass = { modFiles: [], failed: pass.failed };
-            }
-        }
-        const modifiedFiles = pass.modFiles;
-        const applyFailures = pass.failed;
-        // Pre-submit build gate: build the package that owns each changed front-end file (works for any monorepo layout)
-        const verifyFrontendBuilds = async () => {
-            for (const dir of frontendBuildDirs(projectPath, modifiedFiles)) {
-                const buildCmd = fs.existsSync(path.join(dir, 'pnpm-lock.yaml')) ? 'pnpm' : 'npm';
-                const res = await exec(buildCmd, ['run', 'build'], { cwd: dir, timeoutMs: 6 * 60 * 1000 });
-                if (res.timedOut) {
-                    // A slow build is not a compile error: do not throw the work away over it
-                    return { ok: true, note: `The build in \`${path.relative(projectPath, dir) || '.'}\` did not finish within 6 minutes, so it was not verified locally.` };
-                }
-                if (!res.ok) {
-                    return { ok: false, errorOutput: `${res.stdout}\n${res.stderr}`.trim().slice(-1500) };
-                }
-            }
-            return { ok: true };
+        const ownerId = await machineOwnerId(client);
+        const run = {
+            client,
+            card,
+            projectPath,
+            provider,
+            workerLabel,
+            lockFile,
+            profile,
+            carryOverFiles,
+            originalContents,
+            ownerId,
+            conversation: await cardConversation(client, card, ownerId),
+            earlierSummary: priorState?.summary || null,
+            engineNotes: [],
+            rollback,
         };
-        let buildCheck = await verifyFrontendBuilds();
-        if (!buildCheck.ok) {
-            // Revert first pass, attach compiler error context, and do 1 self-correction pass
-            revertAll();
-            modifiedFiles.length = 0;
-            const retryFiles = {
-                ...filesPayload,
-                '__COMPILER_ERROR_TO_FIX__.txt': `The previous edit failed to compile with:\n${buildCheck.errorOutput}\nPlease fix the TypeScript/build error using the exact property names from types.ts.`,
-            };
-            editsRes = await client.autonomousStep({
-                card_id: card.id,
-                action: 'generate_edits',
-                files: retryFiles,
-                project_context: projectContext,
-            });
-            const retryPass = await applyEditsPass(editsRes.edits || []);
-            if (retryPass.failed.length > 0) {
-                revertAll();
-                applyFailures.push(...retryPass.failed);
-            }
-            else {
-                modifiedFiles.push(...retryPass.modFiles);
-                buildCheck = await verifyFrontendBuilds();
-                if (!buildCheck.ok) {
-                    revertAll();
-                    modifiedFiles.length = 0;
-                }
-            }
-        }
-        if (modifiedFiles.length === 0) {
-            removeTaskLock(lockFile);
-            revertAll();
-            const buildNote = buildCheck && !buildCheck.ok && buildCheck.errorOutput
-                ? `\n\nThe attempted change did not compile, so it was reverted. Last build error:\n${buildCheck.errorOutput.split('\n').filter((l) => /error/i.test(l)).slice(0, 4).join('\n').slice(0, 600)}`
-                : applyFailures.length > 0
-                    ? `\n\nThe change I generated could not be applied cleanly, so nothing was modified:\n${applyFailures.slice(0, 4).map((f) => `- ${f}`).join('\n').slice(0, 700)}`
-                    : '';
-            await client.askQuestion(card.id, provider, `I inspected ${Object.keys(filesPayload)
-                .map((f) => `\`${f}\``)
-                .join(', ')} but could not make a verified change automatically.${buildNote}\n\nCould you describe exactly where in the app this should appear (page or screen name) and what you expect to see?`);
+        // A real coding agent when this machine has one; the built-in pipeline otherwise
+        const viaAgent = await produceChangeWithAgent(run);
+        if (viaAgent === 'handled')
             return false;
-        }
+        const produced = viaAgent === 'unavailable' ? await produceChangeBuiltIn(run) : viaAgent;
+        if (!produced)
+            return false;
+        const modifiedFiles = produced.modifiedFiles;
         const commitFiles = Array.from(new Set([...carryOverFiles, ...modifiedFiles]));
         let rawDiff = '';
         try {
             rawDiff = (await exec('git', ['--literal-pathspecs', 'diff', '--', ...modifiedFiles], { cwd: projectPath, timeoutMs: 20000 })).stdout.trim();
         }
         catch { }
-        const baseSummary = editsRes.summary ||
+        const baseSummary = produced.summary ||
             `Updated ${modifiedFiles.join(', ')} to complete "${card.title}".`;
-        const plainSummary = baseSummary.replace(/```[\s\S]*?```/g, '').trim() + (buildCheck.note ? `\n\n${buildCheck.note}` : '');
-        const verificationSteps = Array.isArray(editsRes.verification_steps)
-            ? editsRes.verification_steps.map((s, i) => `${i + 1}. ${s}`).join('\n')
-            : (typeof editsRes.verification_steps === 'string' && editsRes.verification_steps.trim() !== ''
-                ? editsRes.verification_steps
+        const plainSummary = baseSummary.replace(/```[\s\S]*?```/g, '').trim() + (produced.buildNote ? `\n\n${produced.buildNote}` : '');
+        const stepsFromAgent = produced.verificationSteps;
+        const verificationSteps = Array.isArray(stepsFromAgent)
+            ? stepsFromAgent.map((s, i) => `${i + 1}. ${String(s).replace(/^\d+[.)]\s*/, '')}`).join('\n')
+            : (typeof stepsFromAgent === 'string' && stepsFromAgent.trim() !== ''
+                ? stepsFromAgent
                 : `1. Check the live update for "${card.title}".\n2. Click **Approve & Deploy to Done** when verified.`);
         const cardState = (stage, extra = {}) => ({
             stage,
@@ -2155,7 +2461,9 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         let deployedNote = '';
         // From here on the edits are owned by the card's saved state (deploy / approval), not by this run's revert safety net
         editsHandedOff = true;
+        rollback.fn = null;
         clearEditJournal(card.id);
+        clearBaseline(card.id);
         if (deployStage === 'review') {
             // Persist first: if this process dies mid-deploy, the re-queued card resumes with the deployment only
             setCardState(projectPath, card.id, cardState('deploy_failed', { last_error: 'The deployment was interrupted before it finished.' }));
@@ -2209,7 +2517,8 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         const logLines = [
             `Claimed card "${card.title}" (${card.id}) in ${projectPath}`,
             `Agent: ${workerLabel} | Model: ${card.agent_model || 'auto'}`,
-            `Selected files: ${Object.keys(filesPayload).join(', ')}`,
+            `Engine: ${produced.engine}`,
+            ...(produced.inspectedFiles.length > 0 ? [`Selected files: ${produced.inspectedFiles.join(', ')}`] : []),
             `Modified & verified files: ${modifiedFiles.join(', ')}`,
             `Deployment route: ${profile.method} (${profile.confidence} confidence, ${profile.source})`,
             `Deployment: ${deployedNote}`,
@@ -2232,13 +2541,13 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         });
         writeTaskLock(lockFile, card, 'completed');
         sendDesktopNotification(`Agile Monster -> Ready for Review`, `Completed "${card.title}" (${modifiedFiles.length} file(s) updated) and moved to Testing / Review!`);
-        log.info('card.review', { card: card.id, files: modifiedFiles.length, deploy: profile.method });
+        log.info('card.review', { card: card.id, files: modifiedFiles.length, deploy: profile.method, engine: produced.engine });
         return true;
     }
     catch (err) {
         removeTaskLock(lockFile);
         // An interrupted run must not leave half-applied, uncommitted edits in the developer's working tree
-        const rolledBack = !editsHandedOff && originalContents.size > 0;
+        let rolledBack = !editsHandedOff && originalContents.size > 0;
         if (rolledBack) {
             for (const [fPath, orig] of originalContents.entries()) {
                 try {
@@ -2247,6 +2556,12 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 catch { }
             }
         }
+        if (!editsHandedOff && rollback.fn) {
+            try {
+                rolledBack = (await rollback.fn()) || rolledBack;
+            }
+            catch { }
+        }
         if (!editsHandedOff)
             clearEditJournal(card.id);
         log.error('card.failed', { card: card.id, project: projectPath, error: errorMessage(err), reverted: rolledBack });