@agilemonster/mcp-server 1.0.22 → 1.0.24

package/dist/server.js

@@ -7,12 +7,13 @@ import crypto from 'node:crypto';
 import { spawn, execSync, execFileSync } from 'node:child_process';
 import { isUtf8 } from 'node:buffer';
 import { fileURLToPath } from 'node:url';
-import { AgileMonsterClient, MCP_SERVER_VERSION } from './client.js';
+import { AgileMonsterClient, MCP_SERVER_VERSION, isClaimConflict } from './client.js';
 import { AGENT_GUIDELINES_MARKDOWN } from './guidelines.js';
 import { knownSecrets, redactResult } from './redact.js';
-import { describeProfile, methodLabel, normalizeMethod, resolveDeployProfile, } from './deploy-profile.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({
@@ -608,7 +609,8 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                 case 'agilemonster_claim_task': {
                     const cardId = args.card_id;
                     const provider = args.provider || projectConfig?.provider || 'antigravity';
-                    const runRef = args.run_ref;
+                    // One id per IDE session, so the server can tell this session from the background daemon
+                    const runRef = args.run_ref?.trim() || sessionRunRef('interactive', provider);
                     const expectedBoardId = projectConfig?.board_id;
                     if (!expectedBoardId) {
                         return {
@@ -623,6 +625,8 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                         };
                     }
                     const card = await client.claimTask(cardId, provider, runRef, expectedBoardId);
+                    // Reported with every pulse from now on: the claim stays ours while this IDE's MCP process lives
+                    holdClaim(cardId, runRef);
                     return {
                         content: [
                             {
@@ -637,6 +641,7 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const provider = args.provider || projectConfig?.provider || 'antigravity';
                     const question = args.question;
                     const card = await client.askQuestion(cardId, provider, question);
+                    releaseClaim(cardId);
                     return {
                         content: [
                             {
@@ -653,6 +658,7 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const tokensUsed = args.tokens_used;
                     const costUsd = args.cost_usd;
                     const card = await client.addProgress(cardId, provider, update, tokensUsed, costUsd);
+                    touchClaim(cardId);
                     return {
                         content: [
                             {
@@ -669,6 +675,7 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const costUsd = args.cost_usd || 0;
                     const note = args.note;
                     const card = await client.recordSpend(cardId, provider, tokens, costUsd, note);
+                    touchClaim(cardId);
                     return {
                         content: [
                             {
@@ -700,6 +707,7 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const targetList = args.target_list || args.target_list_id || undefined;
                     const assignToUserId = args.assign_to_user_id;
                     const card = await client.submitReview(cardId, provider, summary, verificationSteps, targetList, assignToUserId);
+                    releaseClaim(cardId);
                     return {
                         content: [
                             {
@@ -728,6 +736,7 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const provider = args.provider || projectConfig?.provider || 'antigravity';
                     const comment = args.comment;
                     const card = await client.blockTask(cardId, provider, comment);
+                    releaseClaim(cardId);
                     return {
                         content: [
                             {
@@ -742,6 +751,7 @@ Please strictly follow the Agile Monster Task Lifecycle Protocol:
                     const provider = args.provider || projectConfig?.provider || 'antigravity';
                     const comment = args.comment;
                     const card = await client.completeTask(cardId, provider, comment);
+                    releaseClaim(cardId);
                     return {
                         content: [
                             {
@@ -1208,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 = '';
@@ -1288,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 { }
@@ -1351,14 +1366,61 @@ function appendIdeActivityLog(projectPath, entry) {
     }
     catch { }
 }
-function boundProfileOf(card) {
-    return {
+/**
+ * The board binding's deploy profile for a card, as this machine may use it. A route that another account
+ * set arrives as a proposal (or is demoted to one here): see trustBoundRoute and resolveDeployProfile.
+ */
+export function boundProfileOf(card, ownerId) {
+    return (trustBoundRoute({
         deploy_method: card.deploy_method,
         deploy_command: card.deploy_command,
         live_url: card.live_url,
         build_command: card.build_command,
         deploy_source: card.deploy_source,
-    };
+        deploy_set_by: card.deploy_set_by,
+        proposal: card.deploy_proposal || null,
+    }, ownerId) || {});
+}
+// ---------------------------------------------------------------------------
+// Claims held by this process
+// ---------------------------------------------------------------------------
+const PROCESS_STARTED_AT = Date.now();
+/** An interactive claim nobody touched for this long is no longer reported as alive. */
+const CLAIM_REPORT_MAX_IDLE_MS = 4 * 60 * 60 * 1000;
+const heldClaims = new Map();
+/**
+ * The id under which this process claims cards. The server keeps a claim for the session that made it, so
+ * the id is stable for the life of the process. Background runs start with `auto-pulse-`: only those are
+ * re-queued automatically when they stop responding.
+ */
+export function sessionRunRef(kind, provider) {
+    return kind === 'background'
+        ? `auto-pulse-${process.pid}-${PROCESS_STARTED_AT}`
+        : `ide-${(provider || 'agent').replace(/[^a-z0-9_]+/gi, '-').slice(0, 24)}-${process.pid}-${PROCESS_STARTED_AT}`;
+}
+export function holdClaim(cardId, runRef) {
+    heldClaims.set(cardId, { runRef, touchedAt: Date.now() });
+}
+/** The agent did something with the card: its claim is still in use. */
+export function touchClaim(cardId) {
+    const held = heldClaims.get(cardId);
+    if (held)
+        held.touchedAt = Date.now();
+}
+export function releaseClaim(cardId) {
+    heldClaims.delete(cardId);
+}
+/** What the next pulse reports as held by this process. */
+export function activeClaims(now = Date.now()) {
+    const out = [];
+    for (const [cardId, held] of heldClaims.entries()) {
+        if (now - held.touchedAt > CLAIM_REPORT_MAX_IDLE_MS) {
+            heldClaims.delete(cardId);
+            continue;
+        }
+        out.push({ card_id: cardId, run_ref: held.runRef });
+    }
+    return out;
 }
 /** Feed the outcome back to the server so the board's binding converges on the route that really works. */
 async function reportOutcome(client, card, projectPath, res) {
@@ -1497,7 +1559,7 @@ async function runRedeployOnlyCard(client, card, projectPath, provider, workerLa
         title: card.title || 'redeploy',
         cardId: card.id,
         redeploy: true,
-        bound: boundProfileOf(card),
+        bound: boundProfileOf(card, await machineOwnerId(client)),
     });
     await reportOutcome(client, card, projectPath, res);
     const blankState = (extra) => ({
@@ -1650,7 +1712,7 @@ async function resumeFailedDeployment(client, card, projectPath, provider, worke
         cardId: card.id,
         files: state.files,
         redeploy: true,
-        bound: boundProfileOf(card),
+        bound: boundProfileOf(card, await machineOwnerId(client)),
         override: directive.method ? { method: directive.method, command: directive.command } : null,
     });
     await reportOutcome(client, card, projectPath, res);
@@ -1727,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;
@@ -1764,11 +2363,27 @@ 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 {
         // 1. Claim the card (automatically moves it from ToDo -> In Progress on the board!)
-        await client.claimTask(card.id, provider, `auto-pulse-${Date.now()}`, card.board_id);
+        const runRef = sessionRunRef('background');
+        try {
+            await client.claimTask(card.id, provider, runRef, card.board_id);
+        }
+        catch (err) {
+            if (isClaimConflict(err)) {
+                // Another session (an IDE agent, or a teammate's machine with the same folder) holds this card.
+                // That is the claim doing its job, not a failure: leave the card and the board alone.
+                removeTaskLock(lockFile);
+                log.info('card.claim_lost', { card: card.id, project: projectPath, reason: errorMessage(err) });
+                return false;
+            }
+            throw err;
+        }
+        holdClaim(card.id, runRef);
         sendDesktopNotification(`Agile Monster -> ${workerLabel}`, `Claimed & moved to In Progress: "${card.title}"`);
         // 1b. Deploy-only resume: the change exists, only shipping it is outstanding
         const priorState = getCardState(projectPath, card.id);
@@ -1788,285 +2403,46 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         if (isRedeployOnlyCard(card)) {
             return await runRedeployOnlyCard(client, card, projectPath, provider, workerLabel, lockFile);
         }
-        const profile = resolveDeployProfile(projectPath, { bound: boundProfileOf(card), 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 profile = resolveDeployProfile(projectPath, { bound: boundProfileOf(card, await machineOwnerId(client)), memory: loadMemory(projectPath) });
+        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,
@@ -2085,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.' }));
@@ -2095,7 +2473,7 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 title: card.title || 'update',
                 cardId: card.id,
                 files: commitFiles,
-                bound: boundProfileOf(card),
+                bound: boundProfileOf(card, await machineOwnerId(client)),
             });
             await reportOutcome(client, card, projectPath, deployInfo);
             if (!deployInfo.ok) {
@@ -2139,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}`,
@@ -2162,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 {
@@ -2177,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 });
@@ -2187,6 +2572,7 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         return false;
     }
     finally {
+        releaseClaim(card.id);
         activeAutonomousCards.delete(card.id);
         activeWork--;
     }
@@ -2288,7 +2674,7 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
         const earlierSuccess = memory.deployed_cards[card.id] || null;
         // The deployment started at review time is still running in CI: wait for its verdict rather than deploying again
         if (stillPending && !isContainerRestartCard) {
-            const profile = resolveDeployProfile(projectPath, { bound: boundProfileOf(card), memory });
+            const profile = resolveDeployProfile(projectPath, { bound: boundProfileOf(card, await machineOwnerId(client)), memory });
             const check = await checkCiOnce(projectPath, stillPending.sha, stillPending.workflow_names, profile.workflows.some((w) => w.isDeploy && w.workflowRun));
             if (check.verdict === 'success') {
                 removePendingVerification(projectPath, card.id);
@@ -2335,7 +2721,7 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
             cardId: card.id,
             files: state?.files,
             redeploy: isContainerRestartCard,
-            bound: boundProfileOf(card),
+            bound: boundProfileOf(card, await machineOwnerId(client)),
         });
         await reportOutcome(client, card, projectPath, res);
         if (!res.ok) {
@@ -2559,6 +2945,12 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
         if (pulseRunning) {
             if (holdsWorkerLock)
                 acquireWorkerLock(role);
+            // The same goes for the cards being worked on: while this pulse is busy nothing else tells the server
+            // they are still held, and a build or deploy step can outlast the claim's lease.
+            const held = activeClaims();
+            if (held.length > 0) {
+                void client.heartbeat(held).catch((err) => log.warn('claim.heartbeat_failed', { error: errorMessage(err) }));
+            }
             return;
         }
         pulseRunning = true;
@@ -2577,6 +2969,7 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000, role =
                 projectPath: config.project_path || process.cwd(),
                 discoveredProjects: includeDiscovery ? client.discoverLocalProjects() : undefined,
                 discoveredModels: includeDiscovery ? client.discoverLocalAgentModels() : undefined,
+                activeClaims: activeClaims(),
             });
             if (consecutiveFailures > 0) {
                 log.info('pulse.recovered', { after_failures: consecutiveFailures });