@agilemonster/mcp-server 1.0.14 → 1.0.16

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { AgileMonsterProjectConfig, AutonomousStepResponse, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.14";
+export declare const MCP_SERVER_VERSION = "1.0.16";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -50,6 +50,15 @@ export declare class AgileMonsterClient {
         default_model?: string | null;
         models: Record<string, string>;
     }>;
+    /**
+     * Auto-detect build command, deployment method, deploy script, and live URL for a project repository.
+     */
+    static inspectProjectProfile(fullPath: string, name: string): {
+        build_command: string | null;
+        deploy_method: string | null;
+        deploy_command: string | null;
+        live_url: string | null;
+    };
     /**
      * Scan the developer's local workspace roots (sibling folders in parent dev dir, ~/dev, ~/Projects, etc.)
      * to discover real project folders so the web UI can auto-match and let the user pick from a dropdown.
@@ -84,5 +93,6 @@ export declare class AgileMonsterClient {
         action: 'select_files' | 'generate_edits';
         file_index?: string[];
         files?: Record<string, string>;
+        project_context?: string;
     }): Promise<AutonomousStepResponse>;
 }

package/dist/client.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
-export const MCP_SERVER_VERSION = '1.0.14';
+export const MCP_SERVER_VERSION = '1.0.16';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -315,17 +315,117 @@ export class AgileMonsterClient {
         catch { }
         // 5. Antigravity
         result.antigravity = {
-            default_model: 'gemini-3.1-pro',
+            default_model: 'gemini-4-argon',
             models: {
+                'gemini-4-argon': 'Gemini 4 Argon (Fallback -> Claude Opus 5.5)',
+                'claude-opus-5-5': 'Claude Opus 5.5',
                 'gemini-3.1-pro': 'Gemini 3.1 Pro',
                 'gemini-3.0-flash': 'Gemini 3.0 Flash',
-                'claude-opus-5-5': 'Claude Opus 5.5',
                 'claude-sonnet-5-5': 'Claude Sonnet 5.5',
                 'gpt-6.1-sol': 'GPT-6.1 Sol',
             },
         };
         return result;
     }
+    /**
+     * Auto-detect build command, deployment method, deploy script, and live URL for a project repository.
+     */
+    static inspectProjectProfile(fullPath, name) {
+        let buildCmd = null;
+        let deployMethod = null;
+        let deployCmd = null;
+        let liveUrl = null;
+        // 1. Detect Build Command
+        try {
+            const fePkg = path.join(fullPath, 'frontend', 'package.json');
+            const rootPkg = path.join(fullPath, 'package.json');
+            if (fs.existsSync(fePkg)) {
+                const pkg = JSON.parse(fs.readFileSync(fePkg, 'utf8'));
+                if (pkg?.scripts?.build) {
+                    buildCmd = fs.existsSync(path.join(fullPath, 'frontend', 'pnpm-lock.yaml'))
+                        ? 'cd frontend && pnpm run build'
+                        : 'cd frontend && npm run build';
+                }
+            }
+            else if (fs.existsSync(rootPkg)) {
+                const pkg = JSON.parse(fs.readFileSync(rootPkg, 'utf8'));
+                if (pkg?.scripts?.build) {
+                    buildCmd = fs.existsSync(path.join(fullPath, 'pnpm-lock.yaml'))
+                        ? 'pnpm run build'
+                        : 'npm run build';
+                }
+            }
+            else if (fs.existsSync(path.join(fullPath, 'frontend-flutter', 'pubspec.yaml'))) {
+                buildCmd = 'cd frontend-flutter && flutter analyze';
+            }
+            else if (fs.existsSync(path.join(fullPath, 'pubspec.yaml'))) {
+                buildCmd = 'flutter analyze';
+            }
+        }
+        catch { }
+        // 2. Detect Deploy Method & Command
+        try {
+            const deploySh = path.join(fullPath, 'deploy', 'deploy.sh');
+            const scriptsDeploySh = path.join(fullPath, 'scripts', 'deploy.sh');
+            if (fs.existsSync(deploySh)) {
+                deployMethod = 'deploy_script';
+                const content = fs.readFileSync(deploySh, 'utf8');
+                deployCmd = content.includes('--skip-preflight')
+                    ? './deploy/deploy.sh --skip-preflight'
+                    : './deploy/deploy.sh';
+            }
+            else if (fs.existsSync(scriptsDeploySh)) {
+                deployMethod = 'deploy_script';
+                deployCmd = './scripts/deploy.sh';
+            }
+            else if (fs.existsSync(path.join(fullPath, '.github', 'workflows'))) {
+                deployMethod = 'github_actions';
+                deployCmd = 'git push origin HEAD (GitHub Actions CI/CD)';
+            }
+            else if (fs.existsSync(path.join(fullPath, 'docker-compose.yml'))) {
+                deployMethod = 'docker_compose';
+                deployCmd = 'docker compose up -d --build';
+            }
+            else if (fs.existsSync(path.join(fullPath, '.git'))) {
+                deployMethod = 'git_push';
+                deployCmd = 'git push origin HEAD';
+            }
+        }
+        catch { }
+        // 3. Detect Live URL
+        try {
+            for (const docFile of ['CLAUDE.md', 'AGENTS.md', 'README.md', '.env']) {
+                const docPath = path.join(fullPath, docFile);
+                if (fs.existsSync(docPath)) {
+                    const text = fs.readFileSync(docPath, 'utf8').slice(0, 6000);
+                    const urlMatch = text.match(/https:\/\/(?:www\.)?([a-z0-9-]+\.(?:com|ai|io|app|dev|org|net))\b/i);
+                    if (urlMatch && !/github\.com|openai\.com|anthropic\.com|googleapis\.com|npmjs\.com|localhost/i.test(urlMatch[0])) {
+                        liveUrl = urlMatch[0];
+                        break;
+                    }
+                }
+            }
+            if (!liveUrl) {
+                const clean = name.toLowerCase().replace(/^nieuw\.games[-_]*/i, '');
+                if (/^[a-z0-9-]+\.(com|ai|io|app|dev|org|net)$/i.test(clean)) {
+                    liveUrl = `https://${clean}`;
+                }
+                else if (clean === 'meerlink') {
+                    liveUrl = 'https://meerlink.com';
+                }
+                else if (clean === 'werkinghard' || clean === 'workinghard') {
+                    liveUrl = 'https://werkinghard.com';
+                }
+            }
+        }
+        catch { }
+        return {
+            build_command: buildCmd,
+            deploy_method: deployMethod,
+            deploy_command: deployCmd,
+            live_url: liveUrl,
+        };
+    }
     /**
      * Scan the developer's local workspace roots (sibling folders in parent dev dir, ~/dev, ~/Projects, etc.)
      * to discover real project folders so the web UI can auto-match and let the user pick from a dropdown.
@@ -405,10 +505,12 @@ export class AgileMonsterClient {
                     }
                     catch { }
                 }
+                const profile = AgileMonsterClient.inspectProjectProfile(fullPath, name);
                 found.set(fullPath, {
                     name,
                     path: fullPath,
                     git_remote: gitRemote,
+                    ...profile,
                 });
             }
         }

package/dist/server.d.ts

@@ -36,7 +36,13 @@ export declare function createServer(client?: AgileMonsterClient): Server<{
     } | undefined;
 }>;
 export declare function executeQueuedCardAutonomously(client: AgileMonsterClient, card: Card, projectPath: string): Promise<boolean>;
+/**
+ * Deploy a card the human approved into Done (or flagged as `deploying`).
+ * Idempotent: keyed on card ID only (never on `updated_at`, which changes whenever we post a comment),
+ * so a card is deployed at most once unless the human explicitly re-triggers it into `deploying`.
+ */
 export declare function deployApprovedCardIfNeeded(client: AgileMonsterClient, card: Card, projectPath: string): Promise<boolean>;
-export declare function startBuiltInPullPulse(server: Server | null, client: AgileMonsterClient, intervalMs?: number): NodeJS.Timeout;
+export declare function acquireWorkerLock(role: 'daemon' | 'stdio'): boolean;
+export declare function startBuiltInPullPulse(server: Server | null, client: AgileMonsterClient, intervalMs?: number, role?: 'daemon' | 'stdio'): NodeJS.Timeout;
 export declare function runStdioServer(): Promise<void>;
 export declare function runBackgroundPulseDaemon(intervalMs?: number): Promise<void>;

package/dist/server.js

@@ -761,15 +761,9 @@ function syncIdeTaskRules(boardName, queuedCards) {
     }
     catch { }
 }
-function triggerBackgroundSelfUpdate() {
+function triggerBackgroundSelfUpdate(targetVersion) {
     try {
-        // 1. Pre-warm latest @agilemonster/mcp-server in npx cache
-        const child = spawn('npx', ['-y', '@agilemonster/mcp-server@latest', '--version'], {
-            stdio: 'ignore',
-            detached: true,
-        });
-        child.unref();
-        // 2. Ensure local .cursor/mcp.json and .mcp.json use @latest so next IDE reload uses latest
+        // 1. Ensure local .cursor/mcp.json and .mcp.json use @latest so next IDE reload uses latest
         const cwd = process.cwd();
         for (const rel of ['.cursor/mcp.json', '.mcp.json', '.vscode/mcp.json']) {
             const p = path.join(cwd, rel);
@@ -784,8 +778,56 @@ function triggerBackgroundSelfUpdate() {
                 catch { }
             }
         }
+        // 2. Install @agilemonster/mcp-server@latest into global/npx cache and then exit(0) so launchd respawns the daemon cleanly
+        const child = spawn('sh', ['-c', 'npm install -g @agilemonster/mcp-server@latest >/dev/null 2>&1 || npx -y @agilemonster/mcp-server@latest --version >/dev/null 2>&1'], {
+            stdio: 'ignore',
+            detached: true,
+        });
+        child.on('exit', () => {
+            appendIdeActivityLog(cwd, {
+                cardId: 'system-update',
+                cardTitle: 'MCP Daemon Auto-Update',
+                agentName: 'Agile Monster Daemon',
+                model: 'system',
+                status: 'updated',
+                summary: `Automatically updated @agilemonster/mcp-server from v${MCP_SERVER_VERSION} to v${targetVersion || 'latest'} and restarted daemon via launchd.`,
+            });
+            setTimeout(() => {
+                process.exit(0);
+            }, 1500).unref();
+        });
+        child.unref();
+    }
+    catch { }
+}
+function readProjectInstructionsContext(projectPath) {
+    const sections = [];
+    for (const docName of ['CLAUDE.md', 'AGENTS.md', 'README.md']) {
+        const docPath = path.join(projectPath, docName);
+        if (fs.existsSync(docPath)) {
+            try {
+                const raw = fs.readFileSync(docPath, 'utf8').trim();
+                if (raw.length > 0) {
+                    sections.push(`=== ${docName} ===\n${raw.slice(0, 1800)}`);
+                }
+            }
+            catch { }
+        }
+        if (sections.join('\n\n').length >= 3000)
+            break;
+    }
+    try {
+        const recentCommits = execSync('git log -n 4 --oneline', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (recentCommits) {
+            sections.push(`=== Recent Git Commits ===\n${recentCommits}`);
+        }
     }
     catch { }
+    return sections.join('\n\n').slice(0, 3800);
 }
 const activeAutonomousCards = new Set();
 function collectProjectSourceFiles(projectPath, keywords) {
@@ -988,15 +1030,31 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             await client.addProgress(card.id, provider, `Card is now **In Progress**, but no matching source files were found in \`${projectPath}\`.`);
             return false;
         }
-        // 3. Ask Agile Monster Autonomous Step to pick the 1-4 most relevant files
+        // 3. Ask Agile Monster Autonomous Step to pick the 1-6 most relevant files
+        const projectContext = readProjectInstructionsContext(projectPath);
         const selectionRes = await client.autonomousStep({
             card_id: card.id,
             action: 'select_files',
             file_index: fileIndex,
+            project_context: projectContext,
         });
-        const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || []).slice(0, 4);
+        const selectedFiles = (selectionRes.target_files || selectionRes.selected_files || []).slice(0, 6);
         if (selectedFiles.length === 0) {
-            selectedFiles.push(...fileIndex.slice(0, 3));
+            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) {
@@ -1015,93 +1073,156 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             .map((f) => `\`${f}\``)
             .join(', ')}. Generating code changes...`);
         // 4. Generate surgical code edits
-        const editsRes = await client.autonomousStep({
+        let editsRes = await client.autonomousStep({
             card_id: card.id,
             action: 'generate_edits',
             files: filesPayload,
+            project_context: projectContext,
         });
-        const edits = editsRes.edits || [];
-        const modifiedFiles = [];
-        const originalContents = new Map();
-        for (const edit of edits) {
-            const relPath = edit.file || edit.path;
-            if (!relPath || !edit.search || typeof edit.replace !== 'string')
-                continue;
-            const fullPath = path.resolve(projectPath, relPath);
-            if (!fullPath.startsWith(path.resolve(projectPath)))
-                continue;
-            if (!fs.existsSync(fullPath))
-                continue;
-            const currentContent = fs.readFileSync(fullPath, 'utf8');
-            if (!originalContents.has(fullPath)) {
-                originalContents.set(fullPath, currentContent);
+        // 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() !== '') {
+            try {
+                if (fs.existsSync(lockFile))
+                    fs.unlinkSync(lockFile);
             }
-            if (currentContent.includes(edit.search)) {
-                const updatedContent = currentContent.replace(edit.search, edit.replace);
-                if (updatedContent !== currentContent) {
-                    // Guard against unbalanced braces/parens/brackets introduced by partial block replacement
-                    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) {
-                        continue;
-                    }
-                    fs.writeFileSync(fullPath, updatedContent, 'utf8');
-                    // Pre-submit static analysis gate for Dart/Flutter and PHP files
-                    if (relPath.endsWith('.dart')) {
-                        try {
-                            execSync(`dart analyze "${fullPath}"`, {
-                                cwd: projectPath,
-                                stdio: ['ignore', 'pipe', 'pipe'],
-                                timeout: 25000,
-                            });
+            catch { }
+            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;
+        }
+        const applyEditsPass = (editsList) => {
+            const modFiles = [];
+            for (const edit of editsList) {
+                const relPath = edit.file || edit.path;
+                if (!relPath || !edit.search || typeof edit.replace !== 'string')
+                    continue;
+                const fullPath = path.resolve(projectPath, relPath);
+                if (!fullPath.startsWith(path.resolve(projectPath)))
+                    continue;
+                if (!fs.existsSync(fullPath))
+                    continue;
+                const currentContent = fs.readFileSync(fullPath, 'utf8');
+                if (!originalContents.has(fullPath)) {
+                    originalContents.set(fullPath, currentContent);
+                }
+                if (currentContent.includes(edit.search)) {
+                    const updatedContent = currentContent.replace(edit.search, edit.replace);
+                    if (updatedContent !== currentContent) {
+                        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) {
+                            continue;
+                        }
+                        fs.writeFileSync(fullPath, updatedContent, 'utf8');
+                        if (relPath.endsWith('.dart')) {
+                            try {
+                                execSync(`dart analyze "${fullPath}"`, {
+                                    cwd: projectPath,
+                                    stdio: ['ignore', 'pipe', 'pipe'],
+                                    timeout: 25000,
+                                });
+                            }
+                            catch (analyzeErr) {
+                                const out = String(analyzeErr?.stdout || '') + String(analyzeErr?.stderr || '');
+                                if (/\berror\s+[•-]/i.test(out)) {
+                                    fs.writeFileSync(fullPath, currentContent, 'utf8');
+                                    continue;
+                                }
+                            }
                         }
-                        catch (analyzeErr) {
-                            const out = String(analyzeErr?.stdout || '') + String(analyzeErr?.stderr || '');
-                            if (/\berror\s+[•-]/i.test(out)) {
-                                // Revert broken Dart edit so it never breaks the build
+                        else if (relPath.endsWith('.php')) {
+                            try {
+                                execSync(`php -l "${fullPath}"`, {
+                                    cwd: projectPath,
+                                    stdio: ['ignore', 'pipe', 'pipe'],
+                                    timeout: 10000,
+                                });
+                            }
+                            catch {
                                 fs.writeFileSync(fullPath, currentContent, 'utf8');
                                 continue;
                             }
                         }
-                    }
-                    else if (relPath.endsWith('.php')) {
-                        try {
-                            execSync(`php -l "${fullPath}"`, {
-                                cwd: projectPath,
-                                stdio: ['ignore', 'pipe', 'pipe'],
-                                timeout: 10000,
-                            });
-                        }
-                        catch {
-                            fs.writeFileSync(fullPath, currentContent, 'utf8');
-                            continue;
+                        if (!modFiles.includes(relPath)) {
+                            modFiles.push(relPath);
                         }
                     }
-                    if (!modifiedFiles.includes(relPath)) {
-                        modifiedFiles.push(relPath);
+                }
+            }
+            return modFiles;
+        };
+        const originalContents = new Map();
+        const modifiedFiles = applyEditsPass(editsRes.edits || []);
+        // Pre-submit frontend build verification gate for root AND monorepo subdirectories (frontend/, web/, client/)
+        const verifyFrontendBuilds = () => {
+            const hasFrontendEdits = modifiedFiles.some((f) => /\.(tsx?|jsx?|vue|css)$/i.test(f));
+            if (!hasFrontendEdits)
+                return { ok: true };
+            const candidateDirs = [
+                projectPath,
+                path.join(projectPath, 'frontend'),
+                path.join(projectPath, 'web'),
+                path.join(projectPath, 'client'),
+            ];
+            for (const dir of candidateDirs) {
+                const pkgJsonPath = path.join(dir, 'package.json');
+                if (!fs.existsSync(pkgJsonPath) || !fs.existsSync(path.join(dir, 'node_modules')))
+                    continue;
+                try {
+                    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+                    if (pkg?.scripts?.build) {
+                        const buildCmd = fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))
+                            ? 'pnpm run build'
+                            : 'npm run build';
+                        execSync(buildCmd, {
+                            cwd: dir,
+                            stdio: ['ignore', 'pipe', 'pipe'],
+                            timeout: 60000,
+                        });
                     }
                 }
+                catch (buildErr) {
+                    const errOut = (String(buildErr?.stdout || '') + '\n' + String(buildErr?.stderr || '')).trim();
+                    return { ok: false, errorOutput: errOut.slice(-1500) };
+                }
             }
-        }
-        // Pre-submit frontend build verification gate for JS/TS/React/Vite/Next.js projects
-        const hasFrontendEdits = modifiedFiles.some((f) => /\.(tsx?|jsx?|vue)$/i.test(f));
-        const pkgJsonPath = path.join(projectPath, 'package.json');
-        if (hasFrontendEdits && fs.existsSync(pkgJsonPath)) {
-            try {
-                const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-                if (pkg?.scripts?.build && fs.existsSync(path.join(projectPath, 'node_modules'))) {
-                    execSync('npm run build', {
-                        cwd: projectPath,
-                        stdio: ['ignore', 'pipe', 'pipe'],
-                        timeout: 45000,
-                    });
+            return { ok: true };
+        };
+        let buildCheck = verifyFrontendBuilds();
+        if (!buildCheck.ok) {
+            // Revert first pass, attach compiler error context, and do 1 self-correction pass
+            for (const [fPath, orig] of originalContents.entries()) {
+                try {
+                    fs.writeFileSync(fPath, orig, 'utf8');
                 }
+                catch { }
             }
-            catch (buildErr) {
-                // Revert broken frontend edits so we never leave the project with a broken build
+            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 retryMods = applyEditsPass(editsRes.edits || []);
+            modifiedFiles.push(...retryMods);
+            buildCheck = verifyFrontendBuilds();
+            if (!buildCheck.ok) {
                 for (const [fPath, orig] of originalContents.entries()) {
                     try {
                         fs.writeFileSync(fPath, orig, 'utf8');
@@ -1122,19 +1243,45 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 }).trim();
             }
             catch { }
+            // Gate C: Commit, push, and run the project's defined deployment pipeline, then VERIFY it actually succeeded.
+            // If deploy_stage is 'done' or 'manual', only commit locally-verified changes and defer deployment to approval.
+            const deployStage = (card.deploy_stage || 'review').toLowerCase();
+            const deployInfo = deployStage === 'review'
+                ? await runProjectDeploymentPipeline(projectPath, card.title || 'update', card.id.slice(0, 8), false, card)
+                : { ok: true, commitHash: '', branch: '', deployedNote: '', errorDetail: '' };
+            if (!deployInfo.ok) {
+                // Never claim success: keep card In Progress (waiting_for_input) with a plain-English diagnostic
+                try {
+                    if (fs.existsSync(lockFile))
+                        fs.unlinkSync(lockFile);
+                }
+                catch { }
+                const reason = (deployInfo.errorDetail || 'Unknown deployment error').slice(0, 700);
+                appendIdeActivityLog(projectPath, {
+                    cardId: card.id,
+                    cardTitle: card.title,
+                    agentName: workerLabel,
+                    model: card.agent_model || 'auto',
+                    status: 'deploy_failed',
+                    summary: `Code change was made but deployment could not be verified: ${reason}`,
+                    files: modifiedFiles,
+                    diff: rawDiff,
+                });
+                await client.askQuestion(card.id, provider, `I made the code change (${modifiedFiles.join(', ')}), but the deployment could not be verified, so I kept this card in progress instead of moving it to Testing.\n\nWhat failed: ${reason}\n\nReply "retry" once the issue is fixed, or tell me how this project should be deployed.`);
+                return false;
+            }
             const baseSummary = editsRes.summary ||
                 `Updated ${modifiedFiles.join(', ')} to complete "${card.title}".`;
-            // Keep card comment concise plain English (no raw code diffs on the card!)
-            const cleanPlainSummary = baseSummary
-                .replace(/```[\s\S]*?```/g, '')
-                .trim();
+            const cleanPlainSummary = baseSummary.replace(/```[\s\S]*?```/g, '').trim() +
+                (deployInfo.deployedNote ? `\n\n${deployInfo.deployedNote}` : '');
             const verificationSteps = editsRes.verification_steps ||
-                `1. Check the updated behavior for "${card.title}".\n2. Click **Approve & Move to Done** to deploy and confirm.`;
+                `1. Check the live update for "${card.title}".\n2. Click **Approve & Deploy to Done** when verified.`;
             const logLines = [
                 `Claimed card "${card.title}" (${card.id}) in ${projectPath}`,
                 `Agent: ${workerLabel} | Model: ${card.agent_model || 'auto'}`,
                 `Selected files: ${Object.keys(filesPayload).join(', ')}`,
                 `Modified & verified files: ${modifiedFiles.join(', ')}`,
+                ...(deployInfo.deployedNote ? [`Deployment: ${deployInfo.deployedNote}`] : []),
                 `Summary: ${cleanPlainSummary}`,
             ];
             appendIdeActivityLog(projectPath, {
@@ -1170,9 +1317,12 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                     fs.unlinkSync(lockFile);
             }
             catch { }
-            await client.askQuestion(card.id, provider, `Inspected ${Object.keys(filesPayload)
+            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)}`
+                : '';
+            await client.askQuestion(card.id, provider, `I inspected ${Object.keys(filesPayload)
                 .map((f) => `\`${f}\``)
-                .join(', ')}, but needed more specific details to apply a verified code change automatically. Reply in the comments with additional details (or open your IDE agent) to continue!`);
+                .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?`);
             return false;
         }
     }
@@ -1192,121 +1342,333 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         activeAutonomousCards.delete(card.id);
     }
 }
+/**
+ * Detect and execute the project's defined deployment pipeline, then VERIFY the result:
+ * 1. Commits modified tracked files and pushes to `origin/<branch>`.
+ * 2. Runs the configured/auto-detected deploy method:
+ *    - `deploy_script` (e.g. `./deploy/deploy.sh --skip-preflight`): requires exit code 0.
+ *    - `github_actions`: polls `gh run list --commit <sha>` until the workflow concludes; a failed run = not deployed.
+ *    - `docker_compose`: runs the deploy command and checks `docker compose ps` for running containers.
+ * 3. If a `live_url` is known, performs an HTTP smoke check (must return < 400).
+ * Returns ok=false with a plain-English `errorDetail` whenever deployment cannot be proven.
+ */
+async function runProjectDeploymentPipeline(projectPath, rawTitle, shortId, forceEmptyCommit = false, profile) {
+    const cleanTitle = (rawTitle || 'update').replace(/["`$\\\r\n]+/g, ' ').trim();
+    let branch = 'main';
+    let commitHash = '';
+    let fullSha = '';
+    const actions = [];
+    const run = (cmd, timeout = 45000) => execSync(cmd, { cwd: projectPath, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout }).trim();
+    const errText = (e) => (String(e?.stderr || '') + '\n' + String(e?.stdout || '') + '\n' + String(e?.message || ''))
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0)
+        .slice(-6)
+        .join(' | ')
+        .slice(0, 700);
+    const detected = AgileMonsterClient.inspectProjectProfile(projectPath, path.basename(projectPath));
+    const deployMethod = (profile?.deploy_method || detected.deploy_method || 'git_push').toLowerCase();
+    const deployCommand = profile?.deploy_command || detected.deploy_command || '';
+    const liveUrl = profile?.live_url || detected.live_url || '';
+    // Step 1: commit & push
+    try {
+        branch = run('git rev-parse --abbrev-ref HEAD') || 'main';
+        const statusOut = run('git status --porcelain -uno');
+        if (statusOut.length > 0) {
+            run('git add -u');
+            run(`git commit -m "feat: ${cleanTitle} [AM-${shortId}]"`);
+        }
+        else if (forceEmptyCommit) {
+            run(`git commit --allow-empty -m "chore: trigger redeploy [AM-${shortId}]"`);
+        }
+        fullSha = run('git rev-parse HEAD');
+        commitHash = fullSha.slice(0, 7);
+        if (fs.existsSync(path.join(projectPath, '.git')) && run('git remote').length > 0) {
+            try {
+                run(`git push origin ${branch}`, 60000);
+                actions.push(`pushed \`${commitHash}\` to \`origin/${branch}\``);
+            }
+            catch (pushErr) {
+                return {
+                    ok: false,
+                    commitHash,
+                    branch,
+                    deployedNote: '',
+                    errorDetail: `git push to origin/${branch} failed (check credentials or branch protection): ${errText(pushErr)}`,
+                };
+            }
+        }
+    }
+    catch (gitErr) {
+        return { ok: false, commitHash, branch, deployedNote: '', errorDetail: `Git commit failed: ${errText(gitErr)}` };
+    }
+    // Step 2: run & verify the deploy method
+    try {
+        if (deployMethod === 'deploy_script') {
+            const cmd = deployCommand && !deployCommand.includes('(')
+                ? deployCommand
+                : './deploy/deploy.sh';
+            const scriptPath = cmd.split(' ')[0];
+            const args = cmd.split(' ').slice(1).join(' ');
+            try {
+                run(`bash "${path.resolve(projectPath, scriptPath)}" ${args}`, 300000);
+            }
+            catch (dErr) {
+                return {
+                    ok: false,
+                    commitHash,
+                    branch,
+                    deployedNote: '',
+                    errorDetail: `Deploy script \`${cmd}\` exited with an error: ${errText(dErr)}`,
+                };
+            }
+            actions.push(`deployed via \`${cmd}\` (exit 0)`);
+        }
+        else if (deployMethod === 'github_actions') {
+            let hasGh = false;
+            try {
+                run('gh --version', 5000);
+                hasGh = true;
+            }
+            catch { }
+            if (!hasGh) {
+                actions.push('triggered GitHub Actions (could not verify: `gh` CLI not installed)');
+            }
+            else {
+                const deadline = Date.now() + 8 * 60 * 1000;
+                let verdict = 'none';
+                let failedName = '';
+                let runUrl = '';
+                // Give GitHub a moment to register the workflow run
+                await new Promise((r) => setTimeout(r, 8000));
+                while (Date.now() < deadline) {
+                    let runs = [];
+                    try {
+                        runs = JSON.parse(run(`gh run list --commit ${fullSha} --json status,conclusion,name,url --limit 10`, 20000) || '[]');
+                    }
+                    catch { }
+                    if (runs.length === 0) {
+                        verdict = 'none';
+                    }
+                    else if (runs.some((r) => r.status !== 'completed')) {
+                        verdict = 'pending';
+                    }
+                    else {
+                        const failed = runs.find((r) => r.conclusion !== 'success' && r.conclusion !== 'skipped');
+                        verdict = failed ? 'failure' : 'success';
+                        failedName = failed?.name || '';
+                        runUrl = (failed || runs[0])?.url || '';
+                        break;
+                    }
+                    if (verdict === 'none' && Date.now() > deadline - 7 * 60 * 1000)
+                        break; // no workflow for this commit after ~1 min
+                    await new Promise((r) => setTimeout(r, 15000));
+                }
+                if (verdict === 'failure') {
+                    return {
+                        ok: false,
+                        commitHash,
+                        branch,
+                        deployedNote: '',
+                        errorDetail: `GitHub Actions workflow "${failedName}" failed for commit ${commitHash}. ${runUrl}`.trim(),
+                    };
+                }
+                if (verdict === 'pending') {
+                    return {
+                        ok: false,
+                        commitHash,
+                        branch,
+                        deployedNote: '',
+                        errorDetail: `GitHub Actions for commit ${commitHash} was still running after 8 minutes. ${runUrl}`.trim(),
+                    };
+                }
+                actions.push(verdict === 'success'
+                    ? `GitHub Actions passed for \`${commitHash}\``
+                    : 'pushed (no GitHub Actions workflow ran for this commit)');
+            }
+        }
+        else if (deployMethod === 'docker_compose') {
+            const cmd = deployCommand || 'docker compose up -d --build';
+            try {
+                run(cmd, 600000);
+                const ps = run('docker compose ps --format json', 20000);
+                if (/"State"\s*:\s*"(exited|dead|restarting)"/i.test(ps)) {
+                    return { ok: false, commitHash, branch, deployedNote: '', errorDetail: 'A Docker container is not running after deploy (exited/restarting).' };
+                }
+            }
+            catch (dErr) {
+                return { ok: false, commitHash, branch, deployedNote: '', errorDetail: `Docker deploy failed: ${errText(dErr)}` };
+            }
+            actions.push('Docker containers rebuilt and running');
+        }
+    }
+    catch (anyErr) {
+        return { ok: false, commitHash, branch, deployedNote: '', errorDetail: errText(anyErr) };
+    }
+    // Step 3: live URL smoke check
+    if (liveUrl && /^https?:\/\//i.test(liveUrl)) {
+        let status = 0;
+        for (let attempt = 0; attempt < 3 && (status === 0 || status >= 400); attempt++) {
+            try {
+                const ctrl = new AbortController();
+                const t = setTimeout(() => ctrl.abort(), 15000);
+                const res = await fetch(liveUrl, { method: 'GET', redirect: 'follow', signal: ctrl.signal });
+                clearTimeout(t);
+                status = res.status;
+            }
+            catch {
+                status = 0;
+            }
+            if (status === 0 || status >= 400)
+                await new Promise((r) => setTimeout(r, 5000));
+        }
+        if (status === 0 || status >= 400) {
+            return {
+                ok: false,
+                commitHash,
+                branch,
+                deployedNote: '',
+                errorDetail: `Deployment finished, but ${liveUrl} returned ${status === 0 ? 'no response' : `HTTP ${status}`}.`,
+            };
+        }
+        actions.push(`verified live at ${liveUrl} (HTTP ${status})`);
+    }
+    const deployedNote = actions.length > 0
+        ? `🚀 **Deployed**: ${actions.join(', ')}.`
+        : `🚀 **Deployed**: commit \`${commitHash}\` on \`${branch}\`.`;
+    return { ok: true, commitHash, branch, deployedNote, errorDetail: '' };
+}
+/**
+ * Deploy a card the human approved into Done (or flagged as `deploying`).
+ * Idempotent: keyed on card ID only (never on `updated_at`, which changes whenever we post a comment),
+ * so a card is deployed at most once unless the human explicitly re-triggers it into `deploying`.
+ */
 export async function deployApprovedCardIfNeeded(client, card, projectPath) {
     if (!projectPath || !fs.existsSync(projectPath))
         return false;
     const shortId = card.id.slice(0, 8);
     const deployLock = path.join(getAgileMonsterLocksDir(), `deployed-${shortId}.json`);
-    const cardUpdatedAt = card.updated_at || '';
+    let existing = null;
     if (fs.existsSync(deployLock)) {
         try {
-            const existing = JSON.parse(fs.readFileSync(deployLock, 'utf8'));
-            if (!cardUpdatedAt || existing?.card_updated_at === cardUpdatedAt) {
-                return false;
-            }
+            existing = JSON.parse(fs.readFileSync(deployLock, 'utf8'));
         }
         catch {
+            existing = { status: 'deployed' }; // unreadable lock: fail safe (never loop)
+        }
+    }
+    const explicitRedeploy = card.agent_status === 'deploying';
+    if (existing) {
+        // Already handled and the human has not explicitly asked for a re-deploy
+        if (!explicitRedeploy)
             return false;
+        // Re-deploy request already being processed / processed for this exact request
+        if (existing.redeploy_of === card.updated_at || existing.status === 'running') {
+            const age = Date.now() - (Date.parse(existing.started_at || '') || 0);
+            if (existing.status !== 'running' || age < 15 * 60 * 1000)
+                return false;
         }
     }
+    // Cards that were already deployed during the Review stage only need the Done confirmation, not another deploy
+    const deployStage = (card.deploy_stage || 'review').toLowerCase();
     const provider = card.agent_provider || 'cursor';
-    const cleanTitle = (card.title || 'update').replace(/["`\r\n]+/g, ' ').trim();
+    const rawText = `${card.title || ''} ${card.description || ''}`;
+    const isContainerRestartCard = /\b(restart|redeploy|rebuild)\b.*\b(container|docker|server|prod)/i.test(rawText);
+    const writeLock = (status, extra = {}) => {
+        try {
+            fs.writeFileSync(deployLock, JSON.stringify({
+                card_id: card.id,
+                status,
+                title: card.title,
+                redeploy_of: explicitRedeploy ? card.updated_at : null,
+                started_at: new Date().toISOString(),
+                ...extra,
+            }), 'utf8');
+        }
+        catch { }
+    };
+    writeLock('running');
     try {
-        fs.writeFileSync(deployLock, JSON.stringify({
-            card_id: card.id,
-            card_updated_at: cardUpdatedAt,
-            title: card.title,
-            started_at: new Date().toISOString(),
-        }), 'utf8');
-        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-        if (!branch || branch === 'HEAD')
+        if (deployStage === 'manual') {
+            writeLock('deployed', { note: 'manual deploy stage' });
             return false;
-        const statusOut = execSync('git status --porcelain -uno', {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-        const rawText = `${card.title || ''} ${card.description || ''}`;
-        const isContainerRestartCard = /\b(restart|redeploy|rebuild)\b.*\b(container|docker|server|prod)/i.test(rawText);
-        if (statusOut.length > 0) {
-            execSync('git add -u', { cwd: projectPath, stdio: 'ignore' });
-            execSync(`git commit -m "feat: ${cleanTitle} [AM-${shortId}]"`, {
-                cwd: projectPath,
-                stdio: 'ignore',
-            });
-            execSync(`git push origin ${branch}`, {
-                cwd: projectPath,
-                stdio: 'ignore',
-            });
-            const commitHash = execSync('git rev-parse --short HEAD', {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
-            const msg = `🚀 **[Auto-Deployed to Production]** Deployment confirmed! Committed and pushed \`${commitHash}\` to \`origin/${branch}\`, and moved card to **Done**.`;
-            await client.completeTask(card.id, provider, msg);
-            appendIdeActivityLog(projectPath, {
-                cardId: card.id,
-                cardTitle: card.title,
-                agentName: card.agent_display_name || provider,
-                model: card.agent_model || 'auto',
-                status: 'done',
-                summary: `Deployment confirmed (${commitHash} -> origin/${branch}). Moved card to Done.`,
-            });
-            sendDesktopNotification(`Agile Monster -> Production Confirmed`, `Deployed "${card.title}" (${commitHash}) and moved to Done!`);
-            return true;
         }
-        else if (isContainerRestartCard) {
-            execSync(`git commit --allow-empty -m "chore: trigger container redeploy [AM-${shortId}]"`, {
-                cwd: projectPath,
-                stdio: 'ignore',
-            });
-            execSync(`git push origin ${branch}`, {
-                cwd: projectPath,
-                stdio: 'ignore',
-            });
-            const commitHash = execSync('git rev-parse --short HEAD', {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
-            const msg = `🚀 **[Auto-Deployed to Production]** Triggered production container rebuild & restart (\`${commitHash}\` on \`origin/${branch}\`) and confirmed move to **Done**.`;
-            await client.completeTask(card.id, provider, msg);
-            appendIdeActivityLog(projectPath, {
-                cardId: card.id,
-                cardTitle: card.title,
-                agentName: card.agent_display_name || provider,
-                model: card.agent_model || 'auto',
-                status: 'done',
-                summary: `Triggered container restart (${commitHash}) and moved card to Done.`,
-            });
-            sendDesktopNotification(`Agile Monster -> Container Redeploy`, `Triggered container restart (${commitHash}) on origin/${branch}!`);
-            return true;
+        if (deployStage === 'review' && !explicitRedeploy && !isContainerRestartCard) {
+            // Already deployed + verified before moving to Testing — nothing more to run.
+            writeLock('deployed', { note: 'deployed at review stage' });
+            return false;
         }
-        else {
-            const headHash = execSync('git rev-parse --short HEAD', {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
-            const msg = `🚀 **[Auto-Deployed to Production]** Confirmed latest commit \`${headHash}\` is pushed to \`origin/${branch}\` and live in production. Moved card to **Done**.`;
-            await client.completeTask(card.id, provider, msg);
-            return true;
+        const res = await runProjectDeploymentPipeline(projectPath, card.title || 'update', shortId, isContainerRestartCard, card);
+        if (!res.ok) {
+            writeLock('failed', { error: res.errorDetail });
+            await client.blockTask(card.id, provider, `⚠️ Deployment could not be verified, so this card was NOT marked as deployed.\n\nWhat failed: ${res.errorDetail}\n\nFix the issue and move the card back to Done (or set it to Deploying) to retry.`);
+            return false;
         }
+        const msg = `${res.deployedNote} Confirmed and moved card to **Done**.`;
+        await client.completeTask(card.id, provider, msg);
+        writeLock('deployed', { commit: res.commitHash, completed_at: new Date().toISOString() });
+        appendIdeActivityLog(projectPath, {
+            cardId: card.id,
+            cardTitle: card.title,
+            agentName: card.agent_display_name || provider,
+            model: card.agent_model || 'auto',
+            status: 'done',
+            summary: msg,
+        });
+        sendDesktopNotification(`Agile Monster -> Production Confirmed`, `Deployed "${card.title}" (${res.commitHash})`);
+        return true;
     }
     catch (err) {
-        try {
-            await client.addProgress(card.id, provider, `⚠️ **[Auto-Deploy Note]** Attempted to auto-push approved changes in \`${projectPath}\`: ${err?.message || String(err)}`);
-        }
-        catch { }
+        writeLock('failed', { error: String(err?.message || err).slice(0, 500) });
         return false;
     }
 }
-export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
+/**
+ * Machine-wide single-worker election. Only ONE process per machine may claim, edit, or deploy cards.
+ * IDE-spawned MCP instances (Cursor, Claude Code, Antigravity, …) can be long-lived and run stale code,
+ * so they defer to the background pulse daemon (role 'daemon' always wins) or to any live, fresh holder.
+ */
+const WORKER_LOCK_STALE_MS = 75 * 1000;
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function acquireWorkerLock(role) {
+    const lockPath = path.join(os.homedir(), '.agilemonster', 'worker.lock.json');
+    try {
+        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+        let holder = null;
+        if (fs.existsSync(lockPath)) {
+            try {
+                holder = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+            }
+            catch {
+                holder = null;
+            }
+        }
+        const holderLive = !!holder?.pid &&
+            holder.pid !== process.pid &&
+            isPidAlive(holder.pid) &&
+            Date.now() - (holder.heartbeat || 0) < WORKER_LOCK_STALE_MS;
+        if (holderLive) {
+            const holderIsDaemon = holder?.role === 'daemon';
+            // A daemon only yields to another live daemon; stdio instances always yield to a live holder.
+            if (role === 'stdio' || holderIsDaemon)
+                return false;
+        }
+        fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, role, version: MCP_SERVER_VERSION, heartbeat: Date.now() }), 'utf8');
+        return true;
+    }
+    catch {
+        return role === 'daemon';
+    }
+}
+export function startBuiltInPullPulse(server, client, intervalMs = 20000, role = 'stdio') {
     const notifiedCardIds = new Set();
     let updateTriggered = false;
     let pulseCount = 0;
@@ -1402,28 +1764,31 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
                     catch { }
                 }
             }
-            // Zero-touch autonomous execution for any queued cards bound to local folders on this machine
-            const boundQueued = res.all_bound_queued_cards || [];
-            for (const qCard of boundQueued) {
-                const targetPath = (qCard.bound_project_path || '').trim() ||
-                    (qCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
-                if (targetPath && fs.existsSync(targetPath)) {
-                    await executeQueuedCardAutonomously(client, qCard, targetPath);
+            // Zero-touch autonomous execution & deployment — ONLY the elected machine-wide worker may do this
+            const isWorker = acquireWorkerLock(role);
+            if (isWorker) {
+                const boundQueued = res.all_bound_queued_cards || [];
+                for (const qCard of boundQueued) {
+                    const targetPath = (qCard.bound_project_path || '').trim() ||
+                        (qCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
+                    if (targetPath && fs.existsSync(targetPath)) {
+                        await executeQueuedCardAutonomously(client, qCard, targetPath);
+                    }
                 }
-            }
-            // Zero-touch auto-commit & push (deploy to production) for cards approved into Production / Done!
-            const boundDone = res.all_bound_done_cards || [];
-            for (const dCard of boundDone) {
-                const targetPath = (dCard.bound_project_path || '').trim() ||
-                    (dCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
-                if (targetPath && fs.existsSync(targetPath)) {
-                    await deployApprovedCardIfNeeded(client, dCard, targetPath);
+                const boundDone = res.all_bound_done_cards || [];
+                for (const dCard of boundDone) {
+                    const targetPath = (dCard.bound_project_path || '').trim() ||
+                        (dCard.board_id === config.board_id ? config.project_path || process.cwd() : '');
+                    if (targetPath && fs.existsSync(targetPath)) {
+                        await deployApprovedCardIfNeeded(client, dCard, targetPath);
+                    }
                 }
             }
             if ((res.version?.force_update_requested || res.version?.update_available) &&
-                !updateTriggered) {
+                !updateTriggered &&
+                role === 'daemon') {
                 updateTriggered = true;
-                triggerBackgroundSelfUpdate();
+                triggerBackgroundSelfUpdate(res.version?.latest_version);
             }
         }
         catch {
@@ -1440,12 +1805,24 @@ export async function runStdioServer() {
     const server = createServer(client);
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    startBuiltInPullPulse(server, client, 20000);
+    startBuiltInPullPulse(server, client, 20000, 'stdio');
 }
 export async function runBackgroundPulseDaemon(intervalMs = 20000) {
     const client = new AgileMonsterClient();
     console.log(`[Agile Monster Pulse Daemon v${MCP_SERVER_VERSION}] Listening for queued agent tasks across all bound repositories (interval: ${intervalMs / 1000}s)...`);
-    startBuiltInPullPulse(null, client, intervalMs);
-    // Keep process alive
-    setInterval(() => { }, 60000);
+    startBuiltInPullPulse(null, client, intervalMs, 'daemon');
+    const selfScript = process.argv[1] || '';
+    const initialMtime = selfScript && fs.existsSync(selfScript) ? fs.statSync(selfScript).mtimeMs : 0;
+    // Auto-restart daemon if mcp-server binary/dist on disk is updated (launchd KeepAlive respawns it cleanly)
+    setInterval(() => {
+        try {
+            if (selfScript && initialMtime > 0 && fs.existsSync(selfScript)) {
+                const curMtime = fs.statSync(selfScript).mtimeMs;
+                if (curMtime > initialMtime + 1000) {
+                    process.exit(0);
+                }
+            }
+        }
+        catch { }
+    }, 30000);
 }

package/dist/types.d.ts

@@ -34,6 +34,12 @@ export interface Card {
     updated_at?: string;
     bound_project_path?: string | null;
     bound_project_name?: string | null;
+    fallback_model?: string | null;
+    build_command?: string | null;
+    deploy_method?: string | null;
+    deploy_command?: string | null;
+    live_url?: string | null;
+    deploy_stage?: string | null;
 }
 export interface Board {
     id: string;
@@ -63,9 +69,17 @@ export interface BoardAgentConfig {
     custom_name?: string;
     short_name?: string | null;
     display_name?: string;
+    preferred_model?: string;
+    fallback_model?: string | null;
+    is_favorite?: boolean;
     project_name?: string | null;
     project_path?: string | null;
     git_remote?: string | null;
+    build_command?: string | null;
+    deploy_method?: string | null;
+    deploy_command?: string | null;
+    live_url?: string | null;
+    deploy_stage?: string | null;
     mcp_version?: string | null;
     connected?: boolean;
     last_connected_at?: string | null;
@@ -83,6 +97,10 @@ export interface DiscoveredProject {
     name: string;
     path: string;
     git_remote?: string | null;
+    build_command?: string | null;
+    deploy_method?: string | null;
+    deploy_command?: string | null;
+    live_url?: string | null;
 }
 export interface PulseResponse {
     board_id: string;
@@ -99,6 +117,13 @@ export interface PulseResponse {
         provider: string;
         project_name: string;
         project_path?: string | null;
+        preferred_model?: string | null;
+        fallback_model?: string | null;
+        build_command?: string | null;
+        deploy_method?: string | null;
+        deploy_command?: string | null;
+        live_url?: string | null;
+        deploy_stage?: string | null;
     }>;
 }
 export interface AutonomousEdit {
@@ -111,6 +136,8 @@ export interface AutonomousEdit {
 export interface AutonomousStepResponse {
     card_id: string;
     action?: 'select_files' | 'generate_edits';
+    needs_clarification?: boolean;
+    clarification_question?: string;
     selected_files?: string[];
     target_files?: string[];
     edits?: AutonomousEdit[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilemonster/mcp-server",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "type": "module",
   "description": "Official Model Context Protocol (MCP) server & Orchestrator for Agile Monster (Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf)",
   "main": "dist/server.js",