@agilemonster/mcp-server 1.0.15 → 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.15";
+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.15';
+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) {
@@ -989,10 +1031,12 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             return false;
         }
         // 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, 6);
         if (selectedFiles.length === 0) {
@@ -1033,7 +1077,27 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
             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() !== '') {
+            try {
+                if (fs.existsSync(lockFile))
+                    fs.unlinkSync(lockFile);
+            }
+            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) {
@@ -1153,6 +1217,7 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 card_id: card.id,
                 action: 'generate_edits',
                 files: retryFiles,
+                project_context: projectContext,
             });
             const retryMods = applyEditsPass(editsRes.edits || []);
             modifiedFiles.push(...retryMods);
@@ -1178,9 +1243,33 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
                 }).trim();
             }
             catch { }
-            // Automatically commit, push, and run the project's defined deployment pipeline (e.g. deploy/deploy.sh, GitHub Actions, or Docker)
-            // so changes are live for testing as soon as the card moves to Testing / QA!
-            const deployInfo = runProjectDeploymentPipeline(projectPath, card.title || 'update', card.id.slice(0, 8));
+            // 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}".`;
             const cleanPlainSummary = baseSummary.replace(/```[\s\S]*?```/g, '').trim() +
@@ -1228,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;
         }
     }
@@ -1251,130 +1343,270 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
     }
 }
 /**
- * Detect and execute the project's defined deployment pipeline:
- * 1. Commits any modified tracked files and pushes to `origin/<branch>`.
- * 2. Runs `deploy/deploy.sh` (or `scripts/deploy.sh`) if present in the repo (e.g. Meerlink cPanel SSH deploy).
- * 3. Or triggers GitHub Actions CI/CD via `git push`.
+ * 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.
  */
-function runProjectDeploymentPipeline(projectPath, rawTitle, shortId, forceEmptyCommit = false) {
-    const cleanTitle = (rawTitle || 'update').replace(/["`\r\n]+/g, ' ').trim();
+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 = execSync('git rev-parse --abbrev-ref HEAD', {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim() || 'main';
-        const statusOut = execSync('git status --porcelain -uno', {
-            cwd: projectPath,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
+        branch = run('git rev-parse --abbrev-ref HEAD') || 'main';
+        const statusOut = run('git status --porcelain -uno');
         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',
-                timeout: 45000,
-            });
-            commitHash = execSync('git rev-parse --short HEAD', {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
-            actions.push(`pushed \`${commitHash}\` to \`origin/${branch}\``);
+            run('git add -u');
+            run(`git commit -m "feat: ${cleanTitle} [AM-${shortId}]"`);
         }
         else if (forceEmptyCommit) {
-            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',
-                timeout: 45000,
-            });
-            commitHash = execSync('git rev-parse --short HEAD', {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
-            actions.push(`triggered redeploy commit \`${commitHash}\` on \`origin/${branch}\``);
+            run(`git commit --allow-empty -m "chore: trigger redeploy [AM-${shortId}]"`);
         }
-        else {
-            commitHash = execSync('git rev-parse --short HEAD', {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).trim();
+        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)}`,
+                };
+            }
         }
-        // Check if the project has a dedicated deploy script (e.g. deploy/deploy.sh in Meerlink)
-        const deployScript = path.join(projectPath, 'deploy', 'deploy.sh');
-        if (fs.existsSync(deployScript)) {
-            const scriptContent = fs.readFileSync(deployScript, 'utf8');
-            const flag = scriptContent.includes('--skip-preflight') ? ' --skip-preflight' : '';
-            execSync(`bash "${deployScript}"${flag}`, {
-                cwd: projectPath,
-                stdio: ['ignore', 'pipe', 'pipe'],
-                timeout: 180000,
-            });
-            actions.push('deployed live via `deploy/deploy.sh`');
+    }
+    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 (fs.existsSync(path.join(projectPath, '.github', 'workflows'))) {
-            actions.push('triggered GitHub Actions CI/CD deployment');
+        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');
         }
-        const deployedNote = actions.length > 0
-            ? `🚀 **Deployed**: Automatically ${actions.join(' and ')}.`
-            : `🚀 **Deployed**: Verified commit \`${commitHash}\` is live on \`origin/${branch}\`.`;
-        return { ok: true, commitHash, branch, deployedNote };
     }
-    catch (err) {
-        return {
-            ok: false,
-            commitHash,
-            branch,
-            deployedNote: '',
-        };
+    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 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 res = runProjectDeploymentPipeline(projectPath, card.title || 'update', shortId, isContainerRestartCard);
-        const msg = res.deployedNote
-            ? `${res.deployedNote} Confirmed and moved card to **Done**.`
-            : `🚀 **Deployed**: Confirmed latest commit \`${res.commitHash}\` is live on \`origin/${res.branch}\` and moved card to **Done**.`;
+        if (deployStage === 'manual') {
+            writeLock('deployed', { note: 'manual deploy stage' });
+            return false;
+        }
+        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;
+        }
+        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,
@@ -1383,18 +1615,60 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
             status: 'done',
             summary: msg,
         });
-        sendDesktopNotification(`Agile Monster -> Production Confirmed`, `Deployed "${card.title}" (${res.commitHash}) and moved to Done!`);
+        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 deploy 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;
@@ -1490,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 {
@@ -1528,25 +1805,20 @@ 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);
+    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 so it never runs stale code in memory
+    // 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) {
-                    const child = spawn(process.execPath, process.argv.slice(1), {
-                        detached: true,
-                        stdio: 'ignore',
-                    });
-                    child.unref();
                     process.exit(0);
                 }
             }

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.15",
+  "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",