@agilemonster/mcp-server 1.0.25 → 1.0.27

package/dist/client.d.ts

@@ -1,5 +1,10 @@
+import type { MachineReport } from './machine.js';
 import { ActiveClaim, AgileMonsterProjectConfig, AutonomousStepResponse, CardComment, DeployReport, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.25";
+export declare const MCP_SERVER_VERSION = "1.0.27";
+export type QuestionOption = string | {
+    label: string;
+    reply: string;
+};
 /** 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;
@@ -22,6 +27,8 @@ export declare class AgileMonsterClient {
     setApiKey(key: string): void;
     loadProjectConfig(): AgileMonsterProjectConfig | null;
     saveProjectConfig(config: AgileMonsterProjectConfig, dir?: string): string;
+    /** True when ~/.agilemonster/config.json already holds a key (what a background service reads). */
+    static hasGlobalApiKey(): boolean;
     static saveGlobalConfig(data: {
         api_key?: string;
     }): string;
@@ -38,7 +45,8 @@ export declare class AgileMonsterClient {
         agents: BoardAgentConfig[];
     }>;
     pulse(options: {
-        boardId: string;
+        /** Omitted by a background service that was not started inside a project folder. */
+        boardId?: string;
         provider?: string;
         projectName?: string;
         projectPath?: string;
@@ -50,6 +58,8 @@ export declare class AgileMonsterClient {
         installedAgents?: string[];
         /** Cards this process holds: the server extends their claim (heartbeat). */
         activeClaims?: ActiveClaim[];
+        /** This computer and the agents on it that can take a card (shown on the board next to a waiting card). */
+        machine?: MachineReport;
     }): Promise<PulseResponse>;
     /** Extend the claims this process holds. Used while a long job keeps the pulse loop busy. */
     heartbeat(activeClaims: ActiveClaim[]): Promise<{
@@ -93,7 +103,11 @@ export declare class AgileMonsterClient {
         cards: Card[];
     }>;
     claimTask(cardId: string, provider: string, runRef?: string, expectedBoardId?: string): Promise<Card>;
-    askQuestion(cardId: string, provider: string, question: string): Promise<Card>;
+    /**
+     * `options` become reply buttons on the card: a plain string is both the button and the reply, a
+     * {label, reply} pair shows one thing and sends another ("Yes, deploy this way" -> "deploy: ./deploy.sh").
+     */
+    askQuestion(cardId: string, provider: string, question: string, options?: QuestionOption[]): Promise<Card>;
     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>;

package/dist/client.js

@@ -4,7 +4,7 @@ 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.25';
+export const MCP_SERVER_VERSION = '1.0.27';
 /** An API call the server answered with an error status. `status` lets callers tell "refused" from "broken". */
 export class ApiError extends Error {
     status;
@@ -111,6 +111,19 @@ export class AgileMonsterClient {
         this.cachedConfig = config;
         return configPath;
     }
+    /** True when ~/.agilemonster/config.json already holds a key (what a background service reads). */
+    static hasGlobalApiKey() {
+        try {
+            const homedir = process.env.HOME || process.env.USERPROFILE || '';
+            if (!homedir)
+                return false;
+            const parsed = JSON.parse(fs.readFileSync(path.join(homedir, '.agilemonster', 'config.json'), 'utf8'));
+            return typeof parsed?.api_key === 'string' && parsed.api_key.trim() !== '';
+        }
+        catch {
+            return false;
+        }
+    }
     static saveGlobalConfig(data) {
         const homedir = process.env.HOME || process.env.USERPROFILE || '';
         if (!homedir)
@@ -216,6 +229,7 @@ export class AgileMonsterClient {
                 discovered_models: options.discoveredModels,
                 installed_agents: installed,
                 active_claims: options.activeClaims && options.activeClaims.length > 0 ? options.activeClaims : undefined,
+                machine: options.machine,
             }),
         });
     }
@@ -453,11 +467,12 @@ export class AgileMonsterClient {
      */
     discoverLocalProjects() {
         const roots = new Set();
+        const homedir = process.env.HOME || process.env.USERPROFILE || '';
         const parentDir = path.dirname(this.cwd);
-        if (parentDir && parentDir !== '/' && parentDir !== this.cwd) {
+        // A background service runs from the home folder: its parent holds other people's homes, not projects
+        if (parentDir && parentDir !== '/' && parentDir !== this.cwd && path.resolve(this.cwd) !== path.resolve(homedir || '/')) {
             roots.add(parentDir);
         }
-        const homedir = process.env.HOME || process.env.USERPROFILE || '';
         if (homedir) {
             for (const sub of ['dev', 'Projects', 'Code', 'repos', 'Developer']) {
                 const candidate = path.join(homedir, sub);
@@ -555,10 +570,14 @@ export class AgileMonsterClient {
             body: JSON.stringify({ provider, run_ref: runRef, board_id: boardId }),
         });
     }
-    async askQuestion(cardId, provider, question) {
+    /**
+     * `options` become reply buttons on the card: a plain string is both the button and the reply, a
+     * {label, reply} pair shows one thing and sends another ("Yes, deploy this way" -> "deploy: ./deploy.sh").
+     */
+    async askQuestion(cardId, provider, question, options) {
         return this.request(`/api/agent/cards/${cardId}/ask-question`, {
             method: 'POST',
-            body: JSON.stringify({ provider, question }),
+            body: JSON.stringify({ provider, question, options: options && options.length > 0 ? options.slice(0, 4) : undefined }),
         });
     }
     async addProgress(cardId, provider, update, tokensUsed, costUsd) {

package/dist/deploy-memory.d.ts

@@ -50,6 +50,11 @@ export interface CardDeployState {
     at: string;
     attempts: number;
     last_error?: string | null;
+    /**
+     * Where the last attempt stopped. 'git' = the change never reached the remote, so a retry only has to push it
+     * (or find that a person already did) — it must not add an empty "redeploy" commit.
+     */
+    failed_stage?: 'git' | 'deploy' | null;
     /** Set when the agent asked "may I deploy with X?": a plain "yes"/"retry" then confirms X. */
     pending_confirmation?: {
         method: string;
@@ -89,6 +94,13 @@ export interface ProjectMemory {
         method: string;
         verified: boolean;
     }>;
+    /**
+     * Cards that are waiting for the owner to decide what to do with a branch that cannot be pushed
+     * (asked BEFORE any work started). Only a reply written after `at` answers the question.
+     */
+    branch_questions: Record<string, {
+        at: string;
+    }>;
 }
 export declare function memoryFileFor(projectPath: string): string;
 /**
@@ -118,5 +130,10 @@ export declare function setExplicitProfile(projectPath: string, explicit: {
 }): ProjectMemory;
 export declare function setCardState(projectPath: string, cardId: string, state: CardDeployState | null): void;
 export declare function getCardState(projectPath: string, cardId: string): CardDeployState | null;
+/** Remember (or, with null, forget) that this card is waiting for a decision about its branch. */
+export declare function setBranchQuestion(projectPath: string, cardId: string, at: string | null): void;
+export declare function getBranchQuestion(projectPath: string, cardId: string): {
+    at: string;
+} | null;
 export declare function addPendingVerification(projectPath: string, pending: PendingVerification): void;
 export declare function removePendingVerification(projectPath: string, cardId: string): void;

package/dist/deploy-memory.js

@@ -71,6 +71,7 @@ export function loadMemory(projectPath) {
                 pending: [],
                 cards: {},
                 deployed_cards: {},
+                branch_questions: {},
             };
             saveMemory(memory);
             return memory;
@@ -86,6 +87,7 @@ export function loadMemory(projectPath) {
         pending: Array.isArray(stored?.pending) ? stored.pending : [],
         cards: stored?.cards && typeof stored.cards === 'object' ? stored.cards : {},
         deployed_cards: stored?.deployed_cards && typeof stored.deployed_cards === 'object' ? stored.deployed_cards : {},
+        branch_questions: stored?.branch_questions && typeof stored.branch_questions === 'object' ? stored.branch_questions : {},
     };
 }
 export function saveMemory(memory) {
@@ -110,6 +112,10 @@ export function saveMemory(memory) {
             .slice(0, deployedIds.length - DEPLOYED_CARDS_LIMIT)
             .forEach((id) => delete memory.deployed_cards[id]);
     }
+    for (const id of Object.keys(memory.branch_questions)) {
+        if (Date.now() - (Date.parse(memory.branch_questions[id].at) || 0) > STALE_CARD_STATE_MS)
+            delete memory.branch_questions[id];
+    }
     memory.history = memory.history.slice(-HISTORY_LIMIT);
     try {
         writeJsonAtomic(memoryFileFor(memory.project_path), memory);
@@ -176,6 +182,20 @@ export function setCardState(projectPath, cardId, state) {
 export function getCardState(projectPath, cardId) {
     return loadMemory(projectPath).cards[cardId] || null;
 }
+/** Remember (or, with null, forget) that this card is waiting for a decision about its branch. */
+export function setBranchQuestion(projectPath, cardId, at) {
+    const memory = loadMemory(projectPath);
+    if (at)
+        memory.branch_questions[cardId] = { at };
+    else if (memory.branch_questions[cardId])
+        delete memory.branch_questions[cardId];
+    else
+        return;
+    saveMemory(memory);
+}
+export function getBranchQuestion(projectPath, cardId) {
+    return loadMemory(projectPath).branch_questions[cardId] || null;
+}
 export function addPendingVerification(projectPath, pending) {
     const memory = loadMemory(projectPath);
     memory.pending = memory.pending.filter((p) => p.card_id !== pending.card_id);

package/dist/deploy-runner.d.ts

@@ -1,5 +1,6 @@
 import { BoundProfile, DeployMethod, DeployProfile } from './deploy-profile.js';
 import { PendingVerification } from './deploy-memory.js';
+import { PushConflict } from './branch-health.js';
 /**
  * Runs a project's deployment and proves it worked.
  *
@@ -39,6 +40,12 @@ export interface DeployResult {
     commitHash: string;
     fullSha: string;
     branch: string;
+    /** The commit reached the remote in this attempt (or was already there). */
+    pushed: boolean;
+    /** Where a failed attempt stopped: 'git' = before the change reached the remote; 'deploy' = after. */
+    stage: 'git' | 'deploy' | null;
+    /** A refused push, worked out: what clashes and which ways out exist. */
+    conflict?: PushConflict;
     deployedNote: string;
     errorDetail: string;
     errorKind: string | null;
@@ -59,6 +66,8 @@ export interface DeployDirective {
     method: DeployMethod | null;
     command: string | null;
     liveUrl: string | null;
+    /** "Ship only this change": leave older unpushed commits out and push just this card's commit. */
+    onlyThis?: boolean;
 }
 /**
  * Parse a human reply to a "deployment failed / may I deploy with X?" question.

package/dist/deploy-runner.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { composeArgs, isRunnableCommand, methodLabel, normalizeMethod, pushPathsMatch, requiresConfirmation, resolveDeployProfile, } from './deploy-profile.js';
 import { loadMemory, recordAttempt } from './deploy-memory.js';
+import { describePushConflict, explainPushConflict } from './branch-health.js';
 import { ensureUserPath, exec, execShell, log, sleep, which } from './runtime.js';
 const FAILURE_TABLE = [
     [
@@ -69,6 +70,7 @@ export function classifyFailure(text) {
     }
     return { kind: 'unknown', hint: '', healable: false };
 }
+const ONLY_THIS_RE = /^(ship |push |deploy )?(only|just) this( one)?( change| card| commit)?$/i;
 const AFFIRMATIVE_RE = /^(retry|re-?deploy|try again|deploy again|go ahead|fixed|yes|yep|ok|okay|confirm(ed)?|do it)[\s.!]*$/i;
 /** A directive value only counts as a command when it starts like one — prose after "Deployment:" never runs. */
 const COMMAND_START_RE = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:\.{1,2}\/|\/|~\/|(?:docker|docker-compose|make|npm|pnpm|yarn|npx|bun|bunx|node|deno|python3?|bash|sh|zsh|fly|flyctl|vercel|netlify|wrangler|firebase|gh|git|rsync|scp|ssh|ansible-playbook|kubectl|helm|terraform|cap|bundle|php|composer|gcloud|aws|az|heroku|task|just|cargo|go|dotnet|mvn|gradle|rake|fab|serverless|sls|cdk|pulumi)(?=\s|$))/;
@@ -91,7 +93,12 @@ export function parseDeployDirective(text) {
     if (directive) {
         const value = directive[1].replace(/^`+|`+$/g, '').trim();
         const asMethod = normalizeMethod(value);
-        if (AFFIRMATIVE_RE.test(value)) {
+        if (ONLY_THIS_RE.test(value.replace(/[\s.!]+$/, ''))) {
+            out.onlyThis = true;
+            out.retry = true;
+            matched = true;
+        }
+        else if (AFFIRMATIVE_RE.test(value)) {
             // "deploy: yes" confirms; it is not a program called `yes`
             out.retry = true;
             matched = true;
@@ -298,12 +305,21 @@ async function commitAndPush(req, profile, pushPolicy) {
                 push = await git(['push', state.remote, state.branch], 90000);
             }
             else {
+                const unmergedFiles = unmerged.split(/\r?\n/).filter(Boolean);
                 await git(['rebase', '--abort']);
+                // The raw Git output is for the log. The card gets what clashes, in words, and the ways out.
+                log.warn('deploy.rebase_conflict', { card: req.cardId, project: cwd, branch: state.branch, files: unmergedFiles, output: pull.tail.slice(0, 600) });
+                if (unmergedFiles.length === 0)
+                    return fail(pull, `Could not bring in the newer commits from ${state.remote}/${state.branch}`);
+                const conflict = await explainPushConflict(cwd, req.cardId, unmergedFiles);
                 return {
                     ...state,
                     ok: false,
                     errorKind: 'rebase_conflict',
-                    errorDetail: `The remote branch \`${state.branch}\` has new commits that conflict with this change, so it could not be pushed: ${pull.tail}`,
+                    conflict: conflict || undefined,
+                    errorDetail: conflict
+                        ? describePushConflict(conflict).detail
+                        : `The change is committed on this computer, but the remote branch \`${state.branch}\` has newer commits that clash with it in ${unmergedFiles.slice(0, 3).map((f) => `\`${f}\``).join(', ')}, so it could not be pushed.`,
                 };
             }
         }
@@ -959,6 +975,8 @@ export async function runDeployment(req) {
         commitHash: (git?.fullSha || '').slice(0, 7),
         fullSha: git?.fullSha || '',
         branch: git?.branch || '',
+        pushed: Boolean(git?.pushed),
+        stage: null,
         deployedNote: '',
         errorDetail: '',
         errorKind: null,
@@ -983,7 +1001,14 @@ export async function runDeployment(req) {
         const kind = git.errorKind || 'git';
         recordAttempt(req.projectPath, { card_id: req.cardId, method: profile.method, command: profile.command, ok: false, kind, error: git.errorDetail, duration_ms: Date.now() - startedAt });
         log.warn('deploy.git_failed', { card: req.cardId, project: req.projectPath, kind, error: git.errorDetail });
-        return result({ errorDetail: git.errorDetail || 'Git failed', errorKind: kind, hint: classifyFailure(git.errorDetail || '').hint || HINTS[kind] || '', healed: git.healed }, git);
+        return result({
+            errorDetail: git.errorDetail || 'Git failed',
+            errorKind: kind,
+            stage: 'git',
+            conflict: git.conflict,
+            hint: git.conflict ? describePushConflict(git.conflict).hint : classifyFailure(git.errorDetail || '').hint || HINTS[kind] || '',
+            healed: git.healed,
+        }, git);
     }
     let step = await runMethod(req, profile, git, changedFiles);
     const healed = [...git.healed, ...step.healed];
@@ -1019,6 +1044,7 @@ export async function runDeployment(req) {
         return result({
             errorDetail: step.errorDetail || 'Deployment failed',
             errorKind: kind,
+            stage: 'deploy',
             hint: HINTS[kind] || classifyFailure(step.errorDetail || '').hint,
             actions: [...git.actions, ...step.actions],
             healed,
@@ -1035,7 +1061,7 @@ export async function runDeployment(req) {
         else if (trusted) {
             const detail = `The deployment ran, but ${profile.liveUrl} returned ${status === 0 ? 'no response' : `HTTP ${status}`}.`;
             recordAttempt(req.projectPath, { card_id: req.cardId, method: profile.method, command: profile.command, ok: false, kind: 'live_check_failed', error: detail, commit: git.fullSha.slice(0, 7), duration_ms: Date.now() - startedAt });
-            return result({ errorDetail: detail, errorKind: 'live_check_failed', hint: 'Check the site, then reply "retry".', actions, healed }, git);
+            return result({ errorDetail: detail, errorKind: 'live_check_failed', stage: 'deploy', hint: 'Check the site, then reply "retry".', actions, healed }, git);
         }
     }
     // A human-pinned route is its own proof of intent; anything else only becomes "what worked" once verified
@@ -1097,6 +1123,19 @@ export function describeFailureForHuman(res) {
             `Or reply \`deploy: manual\` if you deploy this project yourself${others.length > 0 ? `, or pick another route I found: ${others.map((a) => `\`deploy: ${a.command || a.method}\``).join(', ')}` : ''}.`,
         ].join('\n');
     }
+    if (res.conflict) {
+        return [res.errorDetail, '', 'You can choose:', res.hint].join('\n');
+    }
+    if (res.stage === 'git') {
+        // The change never reached the remote. Which deploy route was picked is beside the point here:
+        // say what is in the way first, and keep Git's own words for whoever wants them.
+        const text = res.hint
+            ? [`The change is made, but Git stopped before it reached the remote. ${res.hint}`, '', `Technical detail: ${res.errorDetail.replace(/\s+/g, ' ').slice(0, 400)}`]
+            : [res.errorDetail.slice(0, 900)];
+        if (!/\bretry\b/i.test(text.join(' ')))
+            text.push('', 'Reply **retry** once it is fixed: I will not redo the work, only push it and check the deployment.');
+        return text.join('\n');
+    }
     const lines = [`What failed: ${res.errorDetail.slice(0, 900)}`];
     if (res.hint)
         lines.push('', res.hint);

package/dist/machine.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What this computer tells the board with every pulse: which machine it is, whether the runner is the
+ * background service or a coding tool that happens to be open, and which agents on it can take a card.
+ * The board turns that into what a person reads next to a waiting card ("Codex on Studio Mac is ready",
+ * "Cursor is not signed in").
+ */
+export interface MachineReport {
+    id: string;
+    name: string;
+    platform: string;
+    runner: 'service' | 'ide';
+    mode: 'agents' | 'builtin' | 'custom';
+    agents: Array<{
+        id: string;
+        label: string;
+        ready: boolean;
+        problem: string | null;
+    }>;
+}
+/** A stable id for this computer, made once and kept in ~/.agilemonster/machine.json. */
+export declare function machineIdentity(): {
+    id: string;
+    name: string;
+};
+export declare function machineReport(role: 'daemon' | 'stdio'): Promise<MachineReport>;

package/dist/machine.js

@@ -0,0 +1,32 @@
+import crypto from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import { agentMode, engineStatuses } from './agent-engine.js';
+import { agileMonsterHome, readJson, writeJsonAtomic } from './runtime.js';
+/** A stable id for this computer, made once and kept in ~/.agilemonster/machine.json. */
+export function machineIdentity() {
+    const file = path.join(agileMonsterHome(), 'machine.json');
+    const saved = readJson(file);
+    let id = typeof saved?.id === 'string' && /^[A-Za-z0-9_-]{8,64}$/.test(saved.id) ? saved.id : '';
+    if (!id) {
+        id = crypto.randomUUID();
+        try {
+            writeJsonAtomic(file, { id });
+        }
+        catch { }
+    }
+    const name = (os.hostname() || 'computer').replace(/\.(local|lan|home|localdomain)$/i, '').slice(0, 120);
+    return { id, name };
+}
+export async function machineReport(role) {
+    const { id, name } = machineIdentity();
+    const agents = await engineStatuses();
+    return {
+        id,
+        name,
+        platform: process.platform,
+        runner: role === 'daemon' ? 'service' : 'ide',
+        mode: agentMode(),
+        agents: agents.map((a) => ({ id: a.id, label: a.label, ready: !a.problem, problem: a.problem })),
+    };
+}

package/dist/orchestrator.d.ts

@@ -21,6 +21,8 @@ export declare class AgileMonsterOrchestrator {
         provider?: string;
         ide?: string;
         board?: string;
+        /** False skips installing the background runner (`--no-service`). */
+        service?: boolean;
     }): Promise<void>;
     bootstrapInteractive(options?: {
         provider?: string;

package/dist/orchestrator.js

@@ -6,6 +6,9 @@ import { AGENT_GUIDELINES_MARKDOWN } from './guidelines.js';
 import { configureIdeTargets } from './ide-config.js';
 import { ensureLocalGitExcludes } from './deploy-runner.js';
 import { stripRemoteCredentials } from './redact.js';
+import { describeAgents } from './agent-engine.js';
+import { ensureUserPath } from './runtime.js';
+import { installService } from './service.js';
 export class AgileMonsterOrchestrator {
     client;
     constructor(client = new AgileMonsterClient()) {
@@ -313,15 +316,38 @@ export class AgileMonsterOrchestrator {
         // Configure IDEs (Cursor, Claude Code, Windsurf, Antigravity, VS Code)
         this.configureIdes(apiKey, options?.ide || options?.provider);
         this.ensureGitignore();
-        console.log('\n🎉 Project successfully connected to Agile Monster!');
+        // The background runner: without it cards are only worked while a coding tool is open in this folder
+        let background = false;
+        if (options?.service !== false && process.env.AGILEMONSTER_NO_SERVICE !== '1') {
+            console.log('\n⚙️  Setting up the background runner, so cards are worked with no coding tool open...');
+            try {
+                await ensureUserPath();
+                // The service is not started inside a project folder, so it reads the key from the home config
+                if (!AgileMonsterClient.hasGlobalApiKey())
+                    AgileMonsterClient.saveGlobalConfig({ api_key: apiKey });
+                const svc = await installService({ hasApiKey: true });
+                background = svc.outcome === 'installed' || svc.outcome === 'kept';
+                console.log(`${svc.ok ? '✅' : '⚠️ '} ${svc.message}`);
+            }
+            catch (err) {
+                console.log(`⚠️  The background runner could not be set up: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Which coding agent will actually do the work, and the one step that fixes one that is not ready
+        try {
+            console.log(`\n${await describeAgents()}`);
+        }
+        catch { }
+        console.log('\n🎉 This folder is connected to Agile Monster.');
         console.log('\n======================================================');
-        console.log('               🚀 HOW TO USE IT NOW                   ');
+        console.log('               🚀 WHAT HAPPENS NOW                    ');
         console.log('======================================================');
-        console.log(`1. Open board "${targetBoard.name}" on https://app.agilemonster.com`);
-        console.log(`2. Open any card and assign Worker to "${shortTag ? `Cursor-${shortTag}` : `Cursor: ${targetBoard.name}`}" (or Claude Code / Antigravity).`);
-        console.log('3. In your AI IDE chat inside this project, simply say:');
-        console.log('     "Check my Agile Monster tasks and start the next queued card."');
-        console.log('   Or connect another project folder (e.g. Planogram.ai in Cursor) anytime by running:');
+        console.log(`1. Open the board "${targetBoard.name}" on https://app.agilemonster.com`);
+        console.log(`2. Add a card that says what you want, open it, and under "Assign to AI Agent or Team Member" choose "${shortTag ? `Cursor-${shortTag}` : `Cursor: ${targetBoard.name}`}" (or another agent).`);
+        console.log(background
+            ? '3. That is all. The card is picked up within about 20 seconds, worked in this folder, and comes back to you for review.'
+            : '3. Keep your AI coding tool open in this folder: the card is picked up within about 20 seconds while it is open, and comes back to you for review.');
+        console.log('\nTo connect another project folder, run the same command there:');
         console.log('     cd /path/to/other-project && npx -y @agilemonster/mcp-server bootstrap\n');
     }
     async bootstrapInteractive(options) {

package/dist/server.d.ts

@@ -1,7 +1,19 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { AgileMonsterClient } from './client.js';
+import { AgileMonsterClient, QuestionOption } from './client.js';
 import { ActiveClaim, Card } from './types.js';
 import { BoundProfile } from './deploy-profile.js';
+import { PushConflict } from './branch-health.js';
+/**
+ * The answers a deploy question accepts, as reply buttons: nobody should have to type `deploy: ./deploy.sh`.
+ * A first-time route gets "yes, this way" and "I deploy it myself"; a failure gets "try again".
+ */
+export declare function deployReplyOptions(res: {
+    errorKind?: string | null;
+    method?: string | null;
+    command?: string | null;
+    stage?: 'git' | 'deploy' | null;
+    conflict?: PushConflict;
+}): QuestionOption[];
 export declare function createServer(client?: AgileMonsterClient): Server<{
     method: string;
     params?: {