@agilemonster/mcp-server 1.0.22 → 1.0.23

package/dist/client.d.ts

@@ -1,5 +1,12 @@
-import { AgileMonsterProjectConfig, AutonomousStepResponse, CardComment, DeployReport, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.22";
+import { ActiveClaim, AgileMonsterProjectConfig, AutonomousStepResponse, CardComment, DeployReport, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
+export declare const MCP_SERVER_VERSION = "1.0.23";
+/** An API call the server answered with an error status. `status` lets callers tell "refused" from "broken". */
+export declare class ApiError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+/** The server refused a claim because another agent session holds the card (HTTP 409). */
+export declare function isClaimConflict(err: unknown): boolean;
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -41,7 +48,13 @@ export declare class AgileMonsterClient {
             models: Record<string, string> | string[];
         }>;
         installedAgents?: string[];
+        /** Cards this process holds: the server extends their claim (heartbeat). */
+        activeClaims?: ActiveClaim[];
     }): Promise<PulseResponse>;
+    /** Extend the claims this process holds. Used while a long job keeps the pulse loop busy. */
+    heartbeat(activeClaims: ActiveClaim[]): Promise<{
+        renewed: number;
+    }>;
     /**
      * Cross-platform detection of AI coding agents installed on this computer.
      * Checks for Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf, Aider.

package/dist/client.js

@@ -4,7 +4,20 @@ import { execSync } from 'node:child_process';
 import { resolveDeployProfile } from './deploy-profile.js';
 import { loadMemory } from './deploy-memory.js';
 import { stripRemoteCredentials } from './redact.js';
-export const MCP_SERVER_VERSION = '1.0.22';
+export const MCP_SERVER_VERSION = '1.0.23';
+/** An API call the server answered with an error status. `status` lets callers tell "refused" from "broken". */
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.name = 'ApiError';
+        this.status = status;
+    }
+}
+/** The server refused a claim because another agent session holds the card (HTTP 409). */
+export function isClaimConflict(err) {
+    return err instanceof ApiError && err.status === 409;
+}
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -144,7 +157,7 @@ export class AgileMonsterClient {
         }
         if (!res.ok) {
             const msg = json?.message || json?.error || `HTTP ${res.status}: ${text.slice(0, 150)}`;
-            throw new Error(`Agile Monster API Error: ${msg}`);
+            throw new ApiError(`Agile Monster API Error: ${msg}`, res.status);
         }
         return json;
     }
@@ -202,9 +215,17 @@ export class AgileMonsterClient {
                 discovered_projects: options.discoveredProjects,
                 discovered_models: options.discoveredModels,
                 installed_agents: installed,
+                active_claims: options.activeClaims && options.activeClaims.length > 0 ? options.activeClaims : undefined,
             }),
         });
     }
+    /** Extend the claims this process holds. Used while a long job keeps the pulse loop busy. */
+    async heartbeat(activeClaims) {
+        return this.request('/api/agent/heartbeat', {
+            method: 'POST',
+            body: JSON.stringify({ active_claims: activeClaims }),
+        });
+    }
     /**
      * Cross-platform detection of AI coding agents installed on this computer.
      * Checks for Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf, Aider.

package/dist/deploy-profile.d.ts

@@ -11,7 +11,11 @@ import type { ProjectMemory } from './deploy-memory.js';
  * Precedence: explicit project file > user-set binding > last verified success > ranked evidence.
  */
 export type DeployMethod = 'github_actions' | 'docker_compose' | 'deploy_script' | 'cloud_cli' | 'git_push' | 'manual' | 'none';
-export type ProfileSource = 'explicit' | 'user' | 'learned' | 'verified' | 'detected';
+/**
+ * 'proposed' = a route someone ELSE set for this project on the board (a teammate, or a deployment verified
+ * on another machine). It is never "confirmed" for this computer by that alone.
+ */
+export type ProfileSource = 'explicit' | 'user' | 'learned' | 'verified' | 'detected' | 'proposed';
 export type Confidence = 'high' | 'medium' | 'low';
 export interface PushTrigger {
     branches: string[] | null;
@@ -61,6 +65,16 @@ export interface DeployCandidate {
     /** The deploy workflow only starts when dispatched (pushing alone does not deploy). */
     dispatchOnly?: boolean;
 }
+/** A deploy route another account set on the board binding. The server sends it apart from the confirmed fields. */
+export interface RouteProposal {
+    method?: string | null;
+    command?: string | null;
+    live_url?: string | null;
+    /** How it is stored on the board: 'user' (stated by that person), 'verified' (worked on their machine), 'auto'. */
+    source?: string | null;
+    set_by?: string | null;
+    set_by_name?: string | null;
+}
 export interface BoundProfile {
     deploy_method?: string | null;
     deploy_command?: string | null;
@@ -68,7 +82,18 @@ export interface BoundProfile {
     build_command?: string | null;
     /** 'user' = set by a human, 'verified' = confirmed by a successful deploy, 'auto' = a guess. */
     deploy_source?: string | null;
+    /** The account that set deploy_method / deploy_command on the board. */
+    deploy_set_by?: string | null;
+    /** A route someone else set: used only as described at `resolveDeployProfile`. */
+    proposal?: RouteProposal | null;
 }
+/**
+ * Second check on this side of the wire: the server only sends a binding's route as confirmed to the account
+ * that set it, but what runs in a shell on this computer is decided HERE. If the confirmed fields name a
+ * setter and it is not this machine's account, the route is demoted to a proposal.
+ * `ownerId` null = this machine's account could not be determined; the fields are left as the server sent them.
+ */
+export declare function trustBoundRoute(bound: BoundProfile | null | undefined, ownerId: string | null | undefined): BoundProfile | null;
 export interface GitInfo {
     isRepo: boolean;
     branch: string | null;

package/dist/deploy-profile.js

@@ -1,6 +1,34 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+/**
+ * Second check on this side of the wire: the server only sends a binding's route as confirmed to the account
+ * that set it, but what runs in a shell on this computer is decided HERE. If the confirmed fields name a
+ * setter and it is not this machine's account, the route is demoted to a proposal.
+ * `ownerId` null = this machine's account could not be determined; the fields are left as the server sent them.
+ */
+export function trustBoundRoute(bound, ownerId) {
+    if (!bound)
+        return null;
+    const setBy = (bound.deploy_set_by || '').trim();
+    const hasRoute = Boolean((bound.deploy_method || '').trim() || (bound.deploy_command || '').trim());
+    if (!hasRoute || !setBy || !ownerId || setBy === ownerId)
+        return bound;
+    return {
+        ...bound,
+        deploy_method: null,
+        deploy_command: null,
+        deploy_source: null,
+        proposal: bound.proposal || {
+            method: bound.deploy_method,
+            command: bound.deploy_command,
+            live_url: bound.live_url,
+            source: bound.deploy_source || 'auto',
+            set_by: setBy,
+            set_by_name: null,
+        },
+    };
+}
 // ---------------------------------------------------------------------------
 // Small helpers
 // ---------------------------------------------------------------------------
@@ -898,8 +926,43 @@ export function resolveDeployProfile(projectPath, options = {}) {
     }
     if (bound && boundSource === 'user') {
         const method = normalizeMethod(bound.deploy_method);
+        // The server only sends source "user" to the account that set the route (see trustBoundRoute)
         if (method)
-            return pinned(method, bound.deploy_command || null, 'user', 'set by a teammate in Agile Monster');
+            return pinned(method, bound.deploy_command || null, 'user', 'set by you in Agile Monster');
+    }
+    // A route someone else set on the board. It may steer this machine towards something it could have run
+    // unasked anyway (push and let CI deploy, refresh the detected Compose stack). Anything that puts THEIR
+    // command line, a deploy script, a cloud CLI or a manual dispatch on this computer is asked about once;
+    // only the machine owner's answer on the card confirms it, and it is then remembered locally.
+    const proposal = bound?.proposal || null;
+    const proposalSource = (proposal?.source || '').toLowerCase();
+    const fromProposal = () => {
+        const method = normalizeMethod(proposal?.method);
+        if (!method)
+            return null;
+        const match = candidateFor(method);
+        const theirCommand = isRunnableCommand(proposal?.command) ? (proposal?.command).trim() : null;
+        const custom = theirCommand !== null && theirCommand !== (match?.command || null);
+        const sensitive = requiresConfirmation({ method, dispatchOnly: Boolean(match?.dispatchOnly) });
+        if (!custom && sensitive && !match?.command)
+            return null; // nothing concrete to run or to confirm
+        if (!custom && !match && method !== 'manual' && method !== 'none')
+            return null; // does not apply to this checkout
+        const last = memory?.last_success || null;
+        const ranHereBefore = Boolean(last) && normalizeMethod(last?.method) === method && ((last?.command || '').trim() || null) === (theirCommand || match?.command || null);
+        const needsConfirmation = !ranHereBefore && (custom || sensitive);
+        const who = (proposal?.set_by_name || '').trim() || 'a teammate';
+        const what = proposalSource === 'verified' ? `verified by a deployment on ${who}'s machine` : `set by ${who} in Agile Monster`;
+        return {
+            ...pinned(method, theirCommand, 'proposed', needsConfirmation ? `${what}; not confirmed on this computer yet` : what),
+            confidence: needsConfirmation ? 'medium' : 'high',
+            needsConfirmation,
+        };
+    };
+    if (proposal && proposalSource === 'user') {
+        const proposed = fromProposal();
+        if (proposed)
+            return proposed;
     }
     // What worked last time, as long as it has not started failing since
     const last = memory?.last_success || null;
@@ -917,6 +980,11 @@ export function resolveDeployProfile(projectPath, options = {}) {
             return pinned(method, bound.deploy_command || null, 'verified', 'verified by an earlier deployment recorded in Agile Monster');
         }
     }
+    if (proposal && proposalSource === 'verified') {
+        const proposed = fromProposal();
+        if (proposed)
+            return proposed;
+    }
     const top = candidates[0];
     if (!top) {
         return {

package/dist/deploy-runner.js

@@ -973,7 +973,9 @@ export async function runDeployment(req) {
         log.info('deploy.needs_confirmation', { card: req.cardId, project: req.projectPath, method: profile.method, command: profile.command });
         return result({
             errorKind: 'needs_confirmation',
-            errorDetail: `This project looks like it deploys with ${methodLabel(profile.method)}${profile.command ? ` (\`${profile.command}\`)` : ''}, but I have never run that here and nobody has confirmed it.`,
+            errorDetail: profile.source === 'proposed'
+                ? `On the board this project is set to deploy with ${methodLabel(profile.method)}${profile.command ? ` (\`${profile.command}\`)` : ''}, but that was not set from this computer's account and has never been confirmed here.`
+                : `This project looks like it deploys with ${methodLabel(profile.method)}${profile.command ? ` (\`${profile.command}\`)` : ''}, but I have never run that here and nobody has confirmed it.`,
         });
     }
     const git = await commitAndPush(req, profile, pushPolicy);

package/dist/server.d.ts

@@ -1,6 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { AgileMonsterClient } from './client.js';
-import { Card } from './types.js';
+import { ActiveClaim, Card } from './types.js';
+import { BoundProfile } from './deploy-profile.js';
 export declare function createServer(client?: AgileMonsterClient): Server<{
     method: string;
     params?: {
@@ -36,6 +37,23 @@ export declare function createServer(client?: AgileMonsterClient): Server<{
     } | undefined;
 }>;
 export declare function collectProjectSourceFiles(projectPath: string, keywords: string[]): string[];
+/**
+ * The board binding's deploy profile for a card, as this machine may use it. A route that another account
+ * set arrives as a proposal (or is demoted to one here): see trustBoundRoute and resolveDeployProfile.
+ */
+export declare function boundProfileOf(card: Partial<Card>, ownerId: string | null): BoundProfile;
+/**
+ * The id under which this process claims cards. The server keeps a claim for the session that made it, so
+ * the id is stable for the life of the process. Background runs start with `auto-pulse-`: only those are
+ * re-queued automatically when they stop responding.
+ */
+export declare function sessionRunRef(kind: 'background' | 'interactive', provider?: string): string;
+export declare function holdClaim(cardId: string, runRef: string): void;
+/** The agent did something with the card: its claim is still in use. */
+export declare function touchClaim(cardId: string): void;
+export declare function releaseClaim(cardId: string): void;
+/** What the next pulse reports as held by this process. */
+export declare function activeClaims(now?: number): ActiveClaim[];
 /**
  * Roll back edits left behind by a worker that died mid-card. A file is only restored if it still holds
  * exactly what that worker wrote — anything the developer touched since is left alone.

package/dist/server.js

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

package/dist/types.d.ts

@@ -42,6 +42,25 @@ export interface Card {
     deploy_stage?: string | null;
     /** 'user' = set by a human, 'verified' = confirmed by a successful deploy, 'auto' = a guess. */
     deploy_source?: string | null;
+    /** The account that set the deploy route on the board binding. */
+    deploy_set_by?: string | null;
+    /**
+     * A deploy route that another account set. The server withholds it from deploy_method / deploy_command
+     * and sends it here instead: it is never run on this machine without the owner's confirmation.
+     */
+    deploy_proposal?: {
+        method?: string | null;
+        command?: string | null;
+        live_url?: string | null;
+        source?: string | null;
+        set_by?: string | null;
+        set_by_name?: string | null;
+    } | null;
+}
+/** A card this process has claimed, reported with every pulse so the server keeps the claim alive. */
+export interface ActiveClaim {
+    card_id: string;
+    run_ref: string;
 }
 export interface CardComment {
     id: string;

package/package.json

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