@agilemonster/mcp-server 1.0.12 → 1.0.15

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.12";
+export declare const MCP_SERVER_VERSION = "1.0.15";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -36,7 +36,20 @@ export declare class AgileMonsterClient {
         projectName?: string;
         projectPath?: string;
         discoveredProjects?: DiscoveredProject[];
+        discoveredModels?: Record<string, {
+            default_model?: string | null;
+            models: Record<string, string> | string[];
+        }>;
     }): Promise<PulseResponse>;
+    /**
+     * Discover live models installed/configured across the developer's local AI coding agents
+     * (Codex, Cursor, Claude Code, Hermes, Antigravity) so the Agile Monster app & website
+     * always display the real models available for each selected agent.
+     */
+    discoverLocalAgentModels(): Record<string, {
+        default_model?: string | null;
+        models: Record<string, string>;
+    }>;
     /**
      * 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.
@@ -51,7 +64,11 @@ export declare class AgileMonsterClient {
     addProgress(cardId: string, provider: string, update: string, tokensUsed?: number, costUsd?: number): Promise<Card>;
     recordSpend(cardId: string, provider: string, tokens: number, costUsd: number, note?: string): Promise<Card>;
     setBudget(cardId: string, maxBudgetUsd?: number | null, maxTokens?: number | null): Promise<Card>;
-    submitReview(cardId: string, provider: string, summary: string, verificationSteps?: string, targetList?: string, assignToUserId?: string): Promise<Card>;
+    submitReview(cardId: string, provider: string, summary: string, verificationSteps?: string, targetList?: string, assignToUserId?: string, extra?: {
+        diffText?: string;
+        logText?: string;
+        filesModified?: string;
+    }): Promise<Card>;
     completeTask(cardId: string, provider: string, comment?: string): Promise<Card>;
     blockTask(cardId: string, provider: string, comment?: string): Promise<Card>;
     createFollowupTasks(cardId: string, provider: string, tasks: Array<{

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.12';
+export const MCP_SERVER_VERSION = '1.0.15';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -196,9 +196,136 @@ export class AgileMonsterClient {
                 project_path: options.projectPath,
                 mcp_version: MCP_SERVER_VERSION,
                 discovered_projects: options.discoveredProjects,
+                discovered_models: options.discoveredModels,
             }),
         });
     }
+    /**
+     * Discover live models installed/configured across the developer's local AI coding agents
+     * (Codex, Cursor, Claude Code, Hermes, Antigravity) so the Agile Monster app & website
+     * always display the real models available for each selected agent.
+     */
+    discoverLocalAgentModels() {
+        const homedir = process.env.HOME || process.env.USERPROFILE || '';
+        const result = {};
+        if (!homedir)
+            return result;
+        // 1. Codex (~/.codex/models_cache.json & ~/.codex/config.toml)
+        try {
+            const codexCachePath = path.join(homedir, '.codex', 'models_cache.json');
+            const codexConfigPath = path.join(homedir, '.codex', 'config.toml');
+            let defaultCodex = null;
+            if (fs.existsSync(codexConfigPath)) {
+                const toml = fs.readFileSync(codexConfigPath, 'utf8');
+                const m = toml.match(/^\s*model\s*=\s*["']([^"']+)["']/m);
+                if (m?.[1])
+                    defaultCodex = m[1].trim();
+            }
+            if (fs.existsSync(codexCachePath)) {
+                const raw = JSON.parse(fs.readFileSync(codexCachePath, 'utf8'));
+                const list = Array.isArray(raw?.models) ? raw.models : [];
+                const models = {};
+                for (const item of list) {
+                    const slug = String(item?.slug || item?.id || '').trim();
+                    if (!slug)
+                        continue;
+                    const label = String(item?.display_name || slug).trim();
+                    models[slug] = label;
+                }
+                if (Object.keys(models).length > 0) {
+                    result.codex = { default_model: defaultCodex, models };
+                }
+            }
+        }
+        catch { }
+        // 2. Cursor (~/Library/Application Support/Cursor/User/globalStorage/state.vscdb)
+        try {
+            const cursorDb = path.join(homedir, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb');
+            if (fs.existsSync(cursorDb)) {
+                const out = execSync(`sqlite3 "${cursorDb}" "SELECT value FROM ItemTable WHERE key = 'src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser' LIMIT 1;"`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000 }).trim();
+                if (out) {
+                    const data = JSON.parse(out);
+                    const aiSettings = data?.aiSettings || {};
+                    const defaultCursor = aiSettings?.modelConfig?.composer?.modelName ||
+                        aiSettings?.openAIModel ||
+                        null;
+                    const avail = Array.isArray(data?.availableDefaultModels2) ? data.availableDefaultModels2 : [];
+                    const models = {};
+                    for (const m of avail) {
+                        const name = String(m?.name || '').trim();
+                        if (!name)
+                            continue;
+                        const label = String(m?.clientDisplayName || m?.serverModelName || name).trim();
+                        models[name] = label;
+                    }
+                    if (Object.keys(models).length > 0) {
+                        result.cursor = { default_model: defaultCursor, models };
+                    }
+                }
+            }
+        }
+        catch { }
+        // 3. Claude Code (~/.claude.json)
+        try {
+            const claudePath = path.join(homedir, '.claude.json');
+            if (fs.existsSync(claudePath)) {
+                const data = JSON.parse(fs.readFileSync(claudePath, 'utf8'));
+                const usageKeys = Object.keys(data?.CachedGrowthBookFeatures?.tengu_model_config || {});
+                const models = {
+                    'claude-opus-5-5': 'Claude Opus 5.5',
+                    'claude-sonnet-5-5': 'Claude Sonnet 5.5',
+                    'claude-haiku-5-5': 'Claude Haiku 5.5',
+                    'claude-opus-5': 'Claude Opus 5',
+                    'claude-sonnet-5': 'Claude Sonnet 5',
+                    'claude-fable-5-1': 'Claude Fable 5.1',
+                    'claude-opus-4-8': 'Claude Opus 4.8',
+                    'claude-opus-4-7': 'Claude Opus 4.7',
+                    'claude-opus-4-6': 'Claude Opus 4.6',
+                    'claude-sonnet-4-6': 'Claude Sonnet 4.6',
+                    'claude-haiku-4-5': 'Claude Haiku 4.5',
+                };
+                for (const k of usageKeys) {
+                    if (k.startsWith('claude-') && !models[k]) {
+                        models[k] = k;
+                    }
+                }
+                result.claude_code = { default_model: 'claude-sonnet-5-5', models };
+            }
+        }
+        catch { }
+        // 4. Hermes (~/.hermes/config.yaml)
+        try {
+            const hermesPath = path.join(homedir, '.hermes', 'config.yaml');
+            if (fs.existsSync(hermesPath)) {
+                const yaml = fs.readFileSync(hermesPath, 'utf8');
+                const defMatch = yaml.match(/^\s*default\s*:\s*([^\r\n#]+)/m);
+                const defModel = defMatch?.[1] ? defMatch[1].trim().replace(/^["']|["']$/g, '') : 'qwen/qwen3.8-27b';
+                const models = {};
+                if (defModel)
+                    models[defModel] = `${defModel} (Default)`;
+                models['qwen/qwen3.8-27b'] = 'Qwen 3.8 27B (LM Studio)';
+                models['qwen3.5:397b'] = 'Qwen 3.5 397B';
+                models['glm-4.7'] = 'GLM 4.7';
+                models['theta-1'] = 'Theta 1';
+                models['claude-opus-4-6'] = 'Claude Opus 4.6';
+                models['google/gemini-3-flash-preview'] = 'Gemini 3 Flash Preview';
+                result.hermes = { default_model: defModel, models };
+            }
+        }
+        catch { }
+        // 5. Antigravity
+        result.antigravity = {
+            default_model: 'gemini-3.1-pro',
+            models: {
+                '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;
+    }
     /**
      * 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.
@@ -344,7 +471,7 @@ export class AgileMonsterClient {
             }),
         });
     }
-    async submitReview(cardId, provider, summary, verificationSteps, targetList, assignToUserId) {
+    async submitReview(cardId, provider, summary, verificationSteps, targetList, assignToUserId, extra) {
         return this.request(`/api/agent/cards/${cardId}/submit-review`, {
             method: 'POST',
             body: JSON.stringify({
@@ -355,6 +482,9 @@ export class AgileMonsterClient {
                 target_list_id: targetList,
                 target_list_name: targetList,
                 assign_to_user_id: assignToUserId,
+                diff_text: extra?.diffText,
+                log_text: extra?.logText,
+                files_modified: extra?.filesModified,
             }),
         });
     }

package/dist/server.js

@@ -892,20 +892,79 @@ function getAgileMonsterLocksDir() {
     catch { }
     return dir;
 }
+/**
+ * Append a live, human-readable IDE activity entry to `<projectPath>/.agilemonster/ACTIVITY.md`
+ * (and exclude `.agilemonster/` in `.git/info/exclude` so it never pollutes `git status`).
+ * Developers can open `.agilemonster/ACTIVITY.md` in their IDE at any time to see full agent
+ * troubleshooting logs, files inspected, build verification output, and diffs.
+ */
+function appendIdeActivityLog(projectPath, entry) {
+    try {
+        const amDir = path.join(projectPath, '.agilemonster');
+        if (!fs.existsSync(amDir)) {
+            fs.mkdirSync(amDir, { recursive: true });
+        }
+        const gitExclude = path.join(projectPath, '.git', 'info', 'exclude');
+        if (fs.existsSync(gitExclude)) {
+            const exContent = fs.readFileSync(gitExclude, 'utf8');
+            if (!exContent.includes('.agilemonster/')) {
+                fs.appendFileSync(gitExclude, '\n.agilemonster/\n.agilemonster.json\n', 'utf8');
+            }
+        }
+        const logPath = path.join(amDir, 'ACTIVITY.md');
+        const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19) + ' UTC';
+        const header = !fs.existsSync(logPath)
+            ? `# 🤖 Agile Monster — Live IDE Agent Activity Log\n\nThis file is automatically updated by the Agile Monster agent daemon so you can inspect every task, model, file change, and build check directly in your IDE.\n\n---\n\n`
+            : '';
+        const lines = [
+            `## [${timestamp}] ${entry.cardTitle} (\`${entry.cardId.slice(0, 8)}\`)`,
+            `- **Agent**: ${entry.agentName}  |  **Model**: \`${entry.model || 'auto'}\`  |  **Status**: \`${entry.status}\``,
+        ];
+        if (entry.files && entry.files.length > 0) {
+            lines.push(`- **Files**: ${entry.files.map((f) => `\`${f}\``).join(', ')}`);
+        }
+        lines.push(`- **Summary**: ${entry.summary}`);
+        if (entry.diff && entry.diff.trim().length > 0) {
+            const clippedDiff = entry.diff.length > 4000 ? entry.diff.slice(0, 4000) + '\n... (truncated)' : entry.diff;
+            lines.push('', '```diff', clippedDiff.trim(), '```');
+        }
+        lines.push('', '---', '');
+        fs.appendFileSync(logPath, header + lines.join('\n'), 'utf8');
+    }
+    catch { }
+}
 export async function executeQueuedCardAutonomously(client, card, projectPath) {
     if (!projectPath || !fs.existsSync(projectPath))
         return false;
     if (activeAutonomousCards.has(card.id))
         return false;
     const lockFile = path.join(getAgileMonsterLocksDir(), `task-${card.id.slice(0, 8)}.lock`);
+    const cardUpdatedAt = card.updated_at || '';
     try {
         if (fs.existsSync(lockFile)) {
             const stat = fs.statSync(lockFile);
-            if (Date.now() - stat.mtimeMs < 10 * 60 * 1000) {
-                return false; // Already running or recently processed
+            let existingLock = {};
+            try {
+                existingLock = JSON.parse(fs.readFileSync(lockFile, 'utf8'));
+            }
+            catch { }
+            const sameRevision = cardUpdatedAt !== '' && existingLock?.card_updated_at === cardUpdatedAt;
+            if (existingLock?.status === 'running' && Date.now() - stat.mtimeMs < 3 * 60 * 1000 && sameRevision) {
+                return false; // Currently running on this exact revision
+            }
+            if (existingLock?.status === 'completed' && sameRevision && Date.now() - stat.mtimeMs < 10 * 60 * 1000) {
+                return false; // Already completed this exact revision
+            }
+            if (!cardUpdatedAt && Date.now() - stat.mtimeMs < 3 * 60 * 1000) {
+                return false;
             }
         }
-        fs.writeFileSync(lockFile, JSON.stringify({ card_id: card.id, started_at: new Date().toISOString() }), 'utf8');
+        fs.writeFileSync(lockFile, JSON.stringify({
+            card_id: card.id,
+            card_updated_at: cardUpdatedAt,
+            status: 'running',
+            started_at: new Date().toISOString(),
+        }), 'utf8');
     }
     catch {
         return false;
@@ -929,15 +988,29 @@ 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 selectionRes = await client.autonomousStep({
             card_id: card.id,
             action: 'select_files',
             file_index: fileIndex,
         });
-        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) {
@@ -956,96 +1029,217 @@ 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,
         });
-        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);
-            }
-            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 files
-                    if (relPath.endsWith('.dart')) {
-                        try {
-                            execSync(`dart analyze "${fullPath}"`, {
-                                cwd: projectPath,
-                                stdio: ['ignore', 'pipe', 'pipe'],
-                                timeout: 25000,
-                            });
+        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;
                         }
-                        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
+                        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;
+                                }
+                            }
+                        }
+                        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) };
+                }
+            }
+            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 { }
+            }
+            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,
+            });
+            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');
+                    }
+                    catch { }
+                }
+                modifiedFiles.length = 0;
             }
         }
         if (modifiedFiles.length > 0) {
-            let diffSnippet = '';
+            let rawDiff = '';
             try {
                 const quotedFiles = modifiedFiles.map((f) => `"${f.replace(/"/g, '\\"')}"`).join(' ');
-                const rawDiff = execSync(`git diff -- ${quotedFiles}`, {
+                rawDiff = execSync(`git diff -- ${quotedFiles}`, {
                     cwd: projectPath,
                     encoding: 'utf8',
                     stdio: ['ignore', 'pipe', 'ignore'],
                 }).trim();
-                if (rawDiff) {
-                    const clipped = rawDiff.length > 2500 ? rawDiff.slice(0, 2500) + '\n... (diff truncated)' : rawDiff;
-                    diffSnippet = `\n\n### Code Changes (\`git diff\`)\n\`\`\`diff\n${clipped}\n\`\`\``;
-                }
             }
             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));
             const baseSummary = editsRes.summary ||
-                `Implemented "${card.title}" autonomously across ${modifiedFiles.map((f) => `\`${f}\``).join(', ')}.`;
-            const summary = `${baseSummary}${diffSnippet}`;
+                `Updated ${modifiedFiles.join(', ')} to complete "${card.title}".`;
+            const cleanPlainSummary = baseSummary.replace(/```[\s\S]*?```/g, '').trim() +
+                (deployInfo.deployedNote ? `\n\n${deployInfo.deployedNote}` : '');
             const verificationSteps = editsRes.verification_steps ||
-                `1. Review the code diff above in ${modifiedFiles.join(', ')}\n2. Click **Approve & Move to Production** (or drag to Production) to automatically commit, push, and deploy!`;
-            await client.submitReview(card.id, provider, summary, verificationSteps);
+                `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, {
+                cardId: card.id,
+                cardTitle: card.title,
+                agentName: workerLabel,
+                model: card.agent_model || 'auto',
+                status: 'review',
+                summary: cleanPlainSummary,
+                files: modifiedFiles,
+                diff: rawDiff,
+            });
+            await client.submitReview(card.id, provider, cleanPlainSummary, verificationSteps, undefined, undefined, {
+                diffText: rawDiff,
+                logText: logLines.join('\n'),
+                filesModified: modifiedFiles.join(', '),
+            });
+            try {
+                fs.writeFileSync(lockFile, JSON.stringify({
+                    card_id: card.id,
+                    card_updated_at: cardUpdatedAt,
+                    status: 'completed',
+                    completed_at: new Date().toISOString(),
+                }), 'utf8');
+            }
+            catch { }
             sendDesktopNotification(`Agile Monster -> Ready for Review`, `Completed "${card.title}" (${modifiedFiles.length} file(s) updated) and moved to Testing / Review!`);
             return true;
         }
         else {
-            await client.addProgress(card.id, provider, `Task claimed and moved to **In Progress**. Inspected ${Object.keys(filesPayload)
+            try {
+                if (fs.existsSync(lockFile))
+                    fs.unlinkSync(lockFile);
+            }
+            catch { }
+            await client.askQuestion(card.id, provider, `Inspected ${Object.keys(filesPayload)
                 .map((f) => `\`${f}\``)
-                .join(', ')}. Ready for final IDE review.`);
+                .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!`);
             return false;
         }
     }
     catch (err) {
+        try {
+            if (fs.existsSync(lockFile))
+                fs.unlinkSync(lockFile);
+        }
+        catch { }
         try {
             await client.addProgress(card.id, provider, `Autonomous runner note: ${err?.message || String(err)}`);
         }
@@ -1056,32 +1250,28 @@ export async function executeQueuedCardAutonomously(client, card, projectPath) {
         activeAutonomousCards.delete(card.id);
     }
 }
-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`);
-    if (fs.existsSync(deployLock)) {
-        return false;
-    }
-    const provider = card.agent_provider || 'cursor';
-    const cleanTitle = (card.title || 'update').replace(/["`\r\n]+/g, ' ').trim();
+/**
+ * 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`.
+ */
+function runProjectDeploymentPipeline(projectPath, rawTitle, shortId, forceEmptyCommit = false) {
+    const cleanTitle = (rawTitle || 'update').replace(/["`\r\n]+/g, ' ').trim();
+    let branch = 'main';
+    let commitHash = '';
+    const actions = [];
     try {
-        fs.writeFileSync(deployLock, JSON.stringify({ card_id: card.id, title: card.title, started_at: new Date().toISOString() }), 'utf8');
-        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+        branch = execSync('git rev-parse --abbrev-ref HEAD', {
             cwd: projectPath,
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-        if (!branch || branch === 'HEAD')
-            return false;
+        }).trim() || 'main';
         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}]"`, {
@@ -1091,17 +1281,16 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
             execSync(`git push origin ${branch}`, {
                 cwd: projectPath,
                 stdio: 'ignore',
+                timeout: 45000,
             });
-            const commitHash = execSync('git rev-parse --short HEAD', {
+            commitHash = execSync('git rev-parse --short HEAD', {
                 cwd: projectPath,
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
             }).trim();
-            await client.addProgress(card.id, provider, `🚀 **[Auto-Deployed to Production]** Card approved into **${card.list_name || 'Production'}** — automatically committed and pushed \`${commitHash}\` to \`origin/${branch}\` to trigger the production CI/CD & container deployment pipeline!`);
-            sendDesktopNotification(`Agile Monster -> Production Deploy`, `Pushed "${card.title}" (${commitHash}) to origin/${branch}!`);
-            return true;
+            actions.push(`pushed \`${commitHash}\` to \`origin/${branch}\``);
         }
-        else if (isContainerRestartCard) {
+        else if (forceEmptyCommit) {
             execSync(`git commit --allow-empty -m "chore: trigger container redeploy [AM-${shortId}]"`, {
                 cwd: projectPath,
                 stdio: 'ignore',
@@ -1109,29 +1298,97 @@ export async function deployApprovedCardIfNeeded(client, card, projectPath) {
             execSync(`git push origin ${branch}`, {
                 cwd: projectPath,
                 stdio: 'ignore',
+                timeout: 45000,
             });
-            const commitHash = execSync('git rev-parse --short HEAD', {
+            commitHash = execSync('git rev-parse --short HEAD', {
                 cwd: projectPath,
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
             }).trim();
-            await client.addProgress(card.id, provider, `🚀 **[Auto-Deployed to Production]** Triggered production container rebuild & restart via \`${commitHash}\` on \`origin/${branch}\`.`);
-            sendDesktopNotification(`Agile Monster -> Container Redeploy`, `Triggered container restart (${commitHash}) on origin/${branch}!`);
-            return true;
+            actions.push(`triggered redeploy commit \`${commitHash}\` on \`origin/${branch}\``);
         }
         else {
-            const headHash = execSync('git rev-parse --short HEAD', {
+            commitHash = execSync('git rev-parse --short HEAD', {
                 cwd: projectPath,
                 encoding: 'utf8',
                 stdio: ['ignore', 'pipe', 'ignore'],
             }).trim();
-            await client.addProgress(card.id, provider, `🚀 **[Auto-Deployed to Production]** Verified latest commit \`${headHash}\` is pushed to \`origin/${branch}\` and live in the production CI/CD pipeline.`);
-            return true;
         }
+        // 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`');
+        }
+        else if (fs.existsSync(path.join(projectPath, '.github', 'workflows'))) {
+            actions.push('triggered GitHub Actions CI/CD deployment');
+        }
+        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: '',
+        };
+    }
+}
+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 || '';
+    if (fs.existsSync(deployLock)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(deployLock, 'utf8'));
+            if (!cardUpdatedAt || existing?.card_updated_at === cardUpdatedAt) {
+                return false;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    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);
+    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**.`;
+        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: msg,
+        });
+        sendDesktopNotification(`Agile Monster -> Production Confirmed`, `Deployed "${card.title}" (${res.commitHash}) and moved to Done!`);
+        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)}`);
+            await client.addProgress(card.id, provider, `⚠️ **[Auto-Deploy Note]** Attempted to deploy approved changes in \`${projectPath}\`: ${err?.message || String(err)}`);
         }
         catch { }
         return false;
@@ -1204,7 +1461,7 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
             if (!config?.board_id || !apiKey) {
                 return;
             }
-            const includeDiscovery = pulseCount === 0 || pulseCount % 15 === 0;
+            const includeDiscovery = pulseCount === 0 || pulseCount % 3 === 0;
             pulseCount++;
             const res = await client.pulse({
                 boardId: config.board_id,
@@ -1212,6 +1469,7 @@ export function startBuiltInPullPulse(server, client, intervalMs = 20000) {
                 projectName: config.project_name || path.basename(process.cwd()),
                 projectPath: config.project_path || process.cwd(),
                 discoveredProjects: includeDiscovery ? client.discoverLocalProjects() : undefined,
+                discoveredModels: includeDiscovery ? client.discoverLocalAgentModels() : undefined,
             });
             if (res.saved_bindings && res.saved_bindings.length > 0) {
                 autoProvisionSavedBindings(apiKey, res.saved_bindings);
@@ -1276,6 +1534,23 @@ 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);
+    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
+    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);
+                }
+            }
+        }
+        catch { }
+    }, 30000);
 }

package/dist/types.d.ts

@@ -30,6 +30,8 @@ export interface Card {
     board_name?: string;
     list_name?: string;
     created_by?: string;
+    created_at?: string;
+    updated_at?: string;
     bound_project_path?: string | null;
     bound_project_name?: string | null;
 }

package/package.json

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