@agilemonster/mcp-server 1.0.15 → 1.0.21

package/README.md

@@ -74,7 +74,7 @@ This generates:
 
 ## 🛠️ Available MCP Tools
 
-Agents have access to 8 purpose-built lifecycle tools:
+Agents have access to these purpose-built lifecycle tools:
 
 | Tool | Purpose |
 | :--- | :--- |
@@ -86,6 +86,32 @@ Agents have access to 8 purpose-built lifecycle tools:
 | `agilemonster_add_progress` | Logs implementation progress notes to task comments. |
 | `agilemonster_submit_for_review` | Marks work complete, moves card to Review column, reassigns to human member for confirmation, and posts test instructions. |
 | `agilemonster_create_followup_tasks` | Creates follow-up cards (e.g. "Deploy to Test", "Deploy to Production", "Write integration tests"). |
+| `agilemonster_get_deploy_profile` | How this project deploys: route, exact command, confidence, the evidence behind it, alternatives, and recent outcomes. |
+| `agilemonster_record_deployment` | Records how a deployment went (or pins the route the user stated) so every later task deploys the same proven way. |
+
+---
+
+## 🚀 How deployment is decided (and remembered)
+
+Cards started from the Agile Monster web app run in the background without your IDE's context, so the
+server works out how a project ships from evidence and from what worked before:
+
+1. **Explicit** — `.agilemonster/deploy.json` in the repo (`{"method": "docker_compose", "command": "...", "live_url": "..."}`), or a route pinned with `agilemonster_record_deployment({ pin: true })` / a card reply.
+2. **Learned** — the last deployment that was verified on this machine.
+3. **Evidence, ranked** — a deploy workflow that really fires on a push to the checked-out branch (path filters and `workflow_run` chains included) › a deploy script › a cloud CLI config › the Docker Compose stack that is running from this folder (reused with its exact project name and files) › a compose file › a plain `git push`.
+
+What the runner guarantees:
+
+- **Commits only the files it changed** — never `git add -A`; local files holding your API key are filtered and added to `.git/info/exclude`.
+- **Verifies before claiming "Deployed"** — deploy workflow run for that commit, container state and health, script exit code, and a smoke check of a URL you provided. A guessed URL can never fail a deploy.
+- **Asks once, then remembers** — an unconfirmed deploy script, cloud CLI or manually-dispatched workflow is not run on a guess. Reply on the card with `deploy: <command or method>` to confirm; `retry` re-runs only the deployment, not the code change.
+- **Heals what it can** — starts Docker Desktop/OrbStack if it is installed but stopped, rebases and re-pushes when the remote moved ahead, retries network errors, and falls back to the next route when the chosen one plainly does not apply.
+- **Never reports a slow pipeline as failed** — a CI run that outlives the wait is marked pending and re-checked on later pulses; the outcome is posted on the card.
+
+State lives outside your repositories: `~/.agilemonster/projects/` (per-project deployment history) and
+`~/.agilemonster/logs/daemon.jsonl` (structured daemon log).
+
+Card reply syntax: `retry` · `deploy: github_actions` · `deploy: docker_compose` · `deploy: manual` · `deploy: ./deploy/deploy.sh` · `live url: https://example.com`
 
 ---
 

package/dist/client.d.ts

@@ -1,5 +1,5 @@
-import { AgileMonsterProjectConfig, AutonomousStepResponse, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
-export declare const MCP_SERVER_VERSION = "1.0.15";
+import { AgileMonsterProjectConfig, AutonomousStepResponse, CardComment, DeployReport, Board, BoardAgentConfig, Card, ContextResponse, DiscoveredProject, PulseResponse } from './types.js';
+export declare const MCP_SERVER_VERSION = "1.0.21";
 export declare class AgileMonsterClient {
     private apiKey;
     private baseUrl;
@@ -40,7 +40,13 @@ export declare class AgileMonsterClient {
             default_model?: string | null;
             models: Record<string, string> | string[];
         }>;
+        installedAgents?: string[];
     }): Promise<PulseResponse>;
+    /**
+     * Cross-platform detection of AI coding agents installed on this computer.
+     * Checks for Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf, Aider.
+     */
+    static detectInstalledAgents(): string[];
     /**
      * 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
@@ -50,6 +56,20 @@ export declare class AgileMonsterClient {
         default_model?: string | null;
         models: Record<string, string>;
     }>;
+    /**
+     * Describe how a project folder builds and deploys, for the server's project/board bindings.
+     * Backed by the evidence-ranked resolver (running containers, real workflow triggers, deploy scripts,
+     * project docs) plus this machine's deployment memory, so what the web app shows matches what will run.
+     */
+    static inspectProjectProfile(fullPath: string, _name?: string): {
+        build_command: string | null;
+        deploy_method: string | null;
+        deploy_command: string | null;
+        live_url: string | null;
+        deploy_source: string;
+        deploy_confidence: string;
+        deploy_evidence: 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.
@@ -79,10 +99,17 @@ export declare class AgileMonsterClient {
     }>): Promise<{
         tasks: Card[];
     }>;
+    listComments(cardId: string): Promise<CardComment[]>;
+    /**
+     * Tell the server how a deployment went so the board binding learns the verified route (or the failure).
+     * Older backends do not have this endpoint; that must never break a deployment.
+     */
+    reportDeployment(report: DeployReport): Promise<boolean>;
     autonomousStep(payload: {
         card_id: string;
         action: 'select_files' | 'generate_edits';
         file_index?: string[];
         files?: Record<string, string>;
+        project_context?: string;
     }): Promise<AutonomousStepResponse>;
 }

package/dist/client.js

@@ -1,7 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
-export const MCP_SERVER_VERSION = '1.0.15';
+import { resolveDeployProfile } from './deploy-profile.js';
+import { loadMemory } from './deploy-memory.js';
+import { stripRemoteCredentials } from './redact.js';
+export const MCP_SERVER_VERSION = '1.0.21';
 export class AgileMonsterClient {
     apiKey = '';
     baseUrl;
@@ -85,7 +88,7 @@ export class AgileMonsterClient {
         catch {
             // Ignore reading error
         }
-        this.cachedConfig = null;
+        // Not cached: bootstrap may write the file while this server is running, and the tools must then see it
         return null;
     }
     saveProjectConfig(config, dir) {
@@ -155,7 +158,7 @@ export class AgileMonsterClient {
         if (boardId)
             params.set('board_id', boardId);
         if (gitRemote)
-            params.set('git_remote', gitRemote);
+            params.set('git_remote', stripRemoteCredentials(gitRemote));
         if (detectedIdes && detectedIdes.length > 0) {
             params.set('detected_ides', detectedIdes.join(','));
         }
@@ -180,13 +183,14 @@ export class AgileMonsterClient {
                 agents,
                 project_name: projectName,
                 project_path: projectPath,
-                git_remote: gitRemote,
+                git_remote: gitRemote ? stripRemoteCredentials(gitRemote) : gitRemote,
                 mcp_version: MCP_SERVER_VERSION,
                 connected: true,
             }),
         });
     }
     async pulse(options) {
+        const installed = options.installedAgents || AgileMonsterClient.detectInstalledAgents();
         return this.request('/api/agent/pulse', {
             method: 'POST',
             body: JSON.stringify({
@@ -197,9 +201,73 @@ export class AgileMonsterClient {
                 mcp_version: MCP_SERVER_VERSION,
                 discovered_projects: options.discoveredProjects,
                 discovered_models: options.discoveredModels,
+                installed_agents: installed,
             }),
         });
     }
+    /**
+     * Cross-platform detection of AI coding agents installed on this computer.
+     * Checks for Cursor, Claude Code, Antigravity, Codex, Hermes, Windsurf, Aider.
+     */
+    static detectInstalledAgents() {
+        const homedir = process.env.HOME || process.env.USERPROFILE || '';
+        const detected = new Set();
+        const exists = (...p) => {
+            try {
+                const full = path.join(...p);
+                return fs.existsSync(full);
+            }
+            catch {
+                return false;
+            }
+        };
+        // 1. Antigravity
+        if (exists(homedir, '.gemini') ||
+            exists(homedir, '.antigravity') ||
+            Boolean(process.env.ANTIGRAVITY_APP_DATA_DIR) ||
+            Boolean(process.env.GEMINI_CLI)) {
+            detected.add('antigravity');
+        }
+        // 2. Cursor
+        if (exists(homedir, '.cursor') ||
+            exists(homedir, 'Library', 'Application Support', 'Cursor') ||
+            exists(process.env.APPDATA || '', 'Cursor') ||
+            exists(homedir, '.config', 'Cursor') ||
+            exists(process.cwd(), '.cursor')) {
+            detected.add('cursor');
+        }
+        // 3. Claude Code
+        if (exists(homedir, '.claude') ||
+            exists(homedir, '.claude.json') ||
+            exists(homedir, '.config', 'claude') ||
+            exists(process.cwd(), '.mcp.json')) {
+            detected.add('claude_code');
+        }
+        // 4. Codex
+        if (exists(homedir, '.codex') ||
+            exists(process.cwd(), '.codex')) {
+            detected.add('codex');
+        }
+        // 5. Hermes
+        if (exists(homedir, '.hermes') ||
+            exists(homedir, '.local', 'bin', 'hermes')) {
+            detected.add('hermes');
+        }
+        // 6. Windsurf
+        if (exists(homedir, '.codeium', 'windsurf') ||
+            exists(homedir, '.windsurf') ||
+            exists(homedir, 'Library', 'Application Support', 'Windsurf') ||
+            exists(process.env.APPDATA || '', 'Windsurf') ||
+            exists(homedir, '.config', 'Windsurf')) {
+            detected.add('windsurf');
+        }
+        // 7. Aider
+        if (exists(homedir, '.aider') ||
+            exists(homedir, '.aider.conf.yml')) {
+            detected.add('aider');
+        }
+        return Array.from(detected);
+    }
     /**
      * 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
@@ -315,17 +383,49 @@ export class AgileMonsterClient {
         catch { }
         // 5. Antigravity
         result.antigravity = {
-            default_model: 'gemini-3.1-pro',
+            default_model: 'gemini-4-argon',
             models: {
+                'gemini-4-argon': 'Gemini 4 Argon (Fallback -> Claude Opus 5.5)',
+                'claude-opus-5-5': 'Claude Opus 5.5',
                 'gemini-3.1-pro': 'Gemini 3.1 Pro',
                 'gemini-3.0-flash': 'Gemini 3.0 Flash',
-                'claude-opus-5-5': 'Claude Opus 5.5',
                 'claude-sonnet-5-5': 'Claude Sonnet 5.5',
                 'gpt-6.1-sol': 'GPT-6.1 Sol',
             },
         };
         return result;
     }
+    /**
+     * Describe how a project folder builds and deploys, for the server's project/board bindings.
+     * Backed by the evidence-ranked resolver (running containers, real workflow triggers, deploy scripts,
+     * project docs) plus this machine's deployment memory, so what the web app shows matches what will run.
+     */
+    static inspectProjectProfile(fullPath, _name) {
+        try {
+            const profile = resolveDeployProfile(fullPath, { memory: loadMemory(fullPath) });
+            const source = profile.source === 'explicit' ? 'user' : profile.source === 'learned' || profile.source === 'verified' ? 'verified' : 'auto';
+            return {
+                build_command: profile.buildCommand,
+                deploy_method: profile.method === 'none' ? null : profile.method,
+                deploy_command: profile.command,
+                live_url: profile.liveUrl,
+                deploy_source: source,
+                deploy_confidence: profile.confidence,
+                deploy_evidence: profile.evidence.slice(0, 3).join(' · ').slice(0, 480),
+            };
+        }
+        catch {
+            return {
+                build_command: null,
+                deploy_method: null,
+                deploy_command: null,
+                live_url: null,
+                deploy_source: 'auto',
+                deploy_confidence: 'low',
+                deploy_evidence: '',
+            };
+        }
+    }
     /**
      * 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.
@@ -396,19 +496,19 @@ export class AgileMonsterClient {
                 if (fs.existsSync(path.join(fullPath, '.git'))) {
                     try {
                         gitRemote =
-                            execSync('git config --get remote.origin.url', {
+                            stripRemoteCredentials(execSync('git config --get remote.origin.url', {
                                 cwd: fullPath,
                                 stdio: ['ignore', 'pipe', 'ignore'],
-                            })
-                                .toString()
-                                .trim() || null;
+                            }).toString()) || null;
                     }
                     catch { }
                 }
+                const profile = AgileMonsterClient.inspectProjectProfile(fullPath, name);
                 found.set(fullPath, {
                     name,
                     path: fullPath,
                     git_remote: gitRemote,
+                    ...profile,
                 });
             }
         }
@@ -506,6 +606,26 @@ export class AgileMonsterClient {
             body: JSON.stringify({ provider, tasks }),
         });
     }
+    async listComments(cardId) {
+        const res = await this.request(`/api/cards/${cardId}/comments`);
+        return Array.isArray(res) ? res : res?.comments || [];
+    }
+    /**
+     * Tell the server how a deployment went so the board binding learns the verified route (or the failure).
+     * Older backends do not have this endpoint; that must never break a deployment.
+     */
+    async reportDeployment(report) {
+        try {
+            await this.request('/api/agent/deploy-report', {
+                method: 'POST',
+                body: JSON.stringify({ ...report, mcp_version: MCP_SERVER_VERSION }),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async autonomousStep(payload) {
         return this.request('/api/agent/autonomous-step', {
             method: 'POST',

package/dist/deploy-memory.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Machine-local deployment memory, one file per project folder.
+ *
+ * This is the feedback loop that was missing: every deployment attempt (from the daemon or reported
+ * by an IDE agent) is recorded here, so the next card starts from "what worked last time" instead of
+ * re-guessing — and a method that keeps failing because it does not apply gets demoted instead of retried.
+ *
+ * Lives in ~/.agilemonster/projects/ (never inside the repository, so it can never be committed).
+ */
+export interface DeployAttempt {
+    at: string;
+    card_id?: string | null;
+    method: string;
+    command?: string | null;
+    ok: boolean;
+    pending?: boolean;
+    kind?: string | null;
+    error?: string | null;
+    commit?: string | null;
+    duration_ms?: number;
+    reported_by?: string | null;
+}
+export interface MethodFailures {
+    count: number;
+    last_kind: string | null;
+    last_error: string | null;
+    last_at: string;
+    /** The failure says the method does not apply here (as opposed to a real deploy breaking). */
+    wrong_method: boolean;
+}
+/** A deployment whose CI run had not finished when the daemon stopped waiting; re-checked on later pulses. */
+export interface PendingVerification {
+    card_id: string;
+    card_title: string;
+    provider: string;
+    sha: string;
+    branch: string;
+    workflow_names: string[];
+    started_at: string;
+    run_url?: string | null;
+}
+/** What the agent changed for a card whose deployment has not succeeded (or not run) yet. */
+export interface CardDeployState {
+    stage: 'deploy_failed' | 'awaiting_approval';
+    files: string[];
+    summary: string;
+    verification_steps: string;
+    diff: string;
+    commit: string | null;
+    at: string;
+    attempts: number;
+    last_error?: string | null;
+    /** Set when the agent asked "may I deploy with X?": a plain "yes"/"retry" then confirms X. */
+    pending_confirmation?: {
+        method: string;
+        command: string | null;
+    } | null;
+}
+export interface ProjectMemory {
+    project_path: string;
+    updated_at: string;
+    explicit?: {
+        method: string;
+        command?: string | null;
+        live_url?: string | null;
+        notes?: string | null;
+        set_by?: string | null;
+        set_at: string;
+    } | null;
+    last_success?: {
+        method: string;
+        command?: string | null;
+        live_url?: string | null;
+        at: string;
+        commit?: string | null;
+        card_id?: string | null;
+    } | null;
+    failures: Record<string, MethodFailures>;
+    history: DeployAttempt[];
+    pending: PendingVerification[];
+    cards: Record<string, CardDeployState>;
+    /**
+     * Cards this machine already shipped (kept apart from the rolling history, so approving a card long after
+     * its review-time deployment never looks like "not deployed yet" and triggers a second one).
+     */
+    deployed_cards: Record<string, {
+        at: string;
+        commit: string | null;
+        method: string;
+        verified: boolean;
+    }>;
+}
+export declare function memoryFileFor(projectPath: string): string;
+/**
+ * Recover "how the last deployment worked" from the activity log earlier daemon versions wrote into the
+ * project (`.agilemonster/ACTIVITY.md`), so projects that already deployed successfully keep their route
+ * instead of starting from a fresh guess.
+ */
+export declare function parseLastDeploymentFromActivityLog(logText: string): {
+    method: string;
+    command: null;
+} | null;
+export declare function loadMemory(projectPath: string): ProjectMemory;
+export declare function saveMemory(memory: ProjectMemory): void;
+/** Record the outcome of an attempt and update what the project "knows" about its own deployment. */
+export declare function recordAttempt(projectPath: string, attempt: Omit<DeployAttempt, 'at'> & {
+    live_url?: string | null;
+    wrong_method?: boolean;
+    /** The change went out but nothing could confirm the deployment (no CI run found, `gh` unavailable). */
+    unverified?: boolean;
+}): ProjectMemory;
+export declare function setExplicitProfile(projectPath: string, explicit: {
+    method: string;
+    command?: string | null;
+    live_url?: string | null;
+    notes?: string | null;
+    set_by?: string | null;
+}): ProjectMemory;
+export declare function setCardState(projectPath: string, cardId: string, state: CardDeployState | null): void;
+export declare function getCardState(projectPath: string, cardId: string): CardDeployState | null;
+export declare function addPendingVerification(projectPath: string, pending: PendingVerification): void;
+export declare function removePendingVerification(projectPath: string, cardId: string): void;

package/dist/deploy-memory.js

@@ -0,0 +1,192 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { agileMonsterHome, readJson, writeJsonAtomic } from './runtime.js';
+const HISTORY_LIMIT = 30;
+const CARD_STATE_LIMIT = 200;
+const DEPLOYED_CARDS_LIMIT = 300;
+const STALE_CARD_STATE_MS = 45 * 24 * 60 * 60 * 1000;
+export function memoryFileFor(projectPath) {
+    const resolved = path.resolve(projectPath);
+    const hash = crypto.createHash('sha1').update(resolved).digest('hex').slice(0, 10);
+    const slug = path.basename(resolved).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'project';
+    return path.join(agileMonsterHome(), 'projects', `${slug}-${hash}.json`);
+}
+/**
+ * Recover "how the last deployment worked" from the activity log earlier daemon versions wrote into the
+ * project (`.agilemonster/ACTIVITY.md`), so projects that already deployed successfully keep their route
+ * instead of starting from a fresh guess.
+ */
+export function parseLastDeploymentFromActivityLog(logText) {
+    // The log mixes daemon output with card titles and model-written summaries, so it is only trusted for
+    // WHICH of the two routine routes last succeeded — never for a command to run. (A script route found
+    // this way would still have to be confirmed by a human.) Headings carry card titles: skip them.
+    const lines = logText
+        .split(/\r?\n/)
+        .filter((l) => l.includes('🚀 **Deployed**') && !l.trimStart().startsWith('#'));
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].slice(lines[i].indexOf('🚀 **Deployed**'));
+        if (/deployed (?:via|with) `/i.test(line))
+            return null; // last route was a script/CLI: needs confirmation, not seeding
+        if (/Docker (containers rebuilt|Compose)/i.test(line))
+            return { method: 'docker_compose', command: null };
+        if (/GitHub Actions (deployment )?passed/i.test(line))
+            return { method: 'github_actions', command: null };
+    }
+    return null;
+}
+function seedFromActivityLog(projectPath) {
+    try {
+        const file = path.join(projectPath, '.agilemonster', 'ACTIVITY.md');
+        if (!fs.existsSync(file))
+            return null;
+        const stat = fs.statSync(file);
+        const fd = fs.openSync(file, 'r');
+        const length = Math.min(stat.size, 300 * 1024);
+        const buffer = Buffer.alloc(length);
+        fs.readSync(fd, buffer, 0, length, stat.size - length);
+        fs.closeSync(fd);
+        const found = parseLastDeploymentFromActivityLog(buffer.toString('utf8'));
+        if (!found)
+            return null;
+        return { method: found.method, command: found.command, at: stat.mtime.toISOString(), commit: null, card_id: null };
+    }
+    catch {
+        return null;
+    }
+}
+export function loadMemory(projectPath) {
+    const file = memoryFileFor(projectPath);
+    const stored = readJson(file);
+    if (!stored && !fs.existsSync(file)) {
+        const seeded = seedFromActivityLog(projectPath);
+        if (seeded) {
+            const memory = {
+                project_path: path.resolve(projectPath),
+                updated_at: new Date().toISOString(),
+                explicit: null,
+                last_success: seeded,
+                failures: {},
+                history: [],
+                pending: [],
+                cards: {},
+                deployed_cards: {},
+            };
+            saveMemory(memory);
+            return memory;
+        }
+    }
+    return {
+        project_path: path.resolve(projectPath),
+        updated_at: stored?.updated_at || new Date(0).toISOString(),
+        explicit: stored?.explicit || null,
+        last_success: stored?.last_success || null,
+        failures: stored?.failures && typeof stored.failures === 'object' ? stored.failures : {},
+        history: Array.isArray(stored?.history) ? stored.history : [],
+        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 : {},
+    };
+}
+export function saveMemory(memory) {
+    memory.updated_at = new Date().toISOString();
+    // Card state means "edits exist that still have to ship": only drop it when it is clearly abandoned.
+    const cardIds = Object.keys(memory.cards);
+    for (const id of cardIds) {
+        if (Date.now() - (Date.parse(memory.cards[id].at) || 0) > STALE_CARD_STATE_MS)
+            delete memory.cards[id];
+    }
+    const remaining = Object.keys(memory.cards);
+    if (remaining.length > CARD_STATE_LIMIT) {
+        remaining
+            .sort((a, b) => (memory.cards[a].at < memory.cards[b].at ? -1 : 1))
+            .slice(0, remaining.length - CARD_STATE_LIMIT)
+            .forEach((id) => delete memory.cards[id]);
+    }
+    const deployedIds = Object.keys(memory.deployed_cards);
+    if (deployedIds.length > DEPLOYED_CARDS_LIMIT) {
+        deployedIds
+            .sort((a, b) => (memory.deployed_cards[a].at < memory.deployed_cards[b].at ? -1 : 1))
+            .slice(0, deployedIds.length - DEPLOYED_CARDS_LIMIT)
+            .forEach((id) => delete memory.deployed_cards[id]);
+    }
+    memory.history = memory.history.slice(-HISTORY_LIMIT);
+    try {
+        writeJsonAtomic(memoryFileFor(memory.project_path), memory);
+    }
+    catch {
+        // Memory is an optimization; failing to persist it must never fail a deployment.
+    }
+}
+/** Record the outcome of an attempt and update what the project "knows" about its own deployment. */
+export function recordAttempt(projectPath, attempt) {
+    const memory = loadMemory(projectPath);
+    const at = new Date().toISOString();
+    const { live_url: liveUrl, wrong_method: wrongMethod, unverified, ...rest } = attempt;
+    memory.history.push({ at, ...rest, error: rest.error ? rest.error.slice(0, 600) : rest.error });
+    if (attempt.ok && attempt.card_id) {
+        memory.deployed_cards[attempt.card_id] = {
+            at,
+            commit: attempt.commit || null,
+            method: attempt.method,
+            verified: !attempt.pending && !unverified,
+        };
+    }
+    // Only a deployment that was actually verified teaches the project its route
+    if (attempt.ok && !attempt.pending && !unverified) {
+        memory.last_success = {
+            method: attempt.method,
+            command: attempt.command || null,
+            live_url: liveUrl || memory.last_success?.live_url || null,
+            at,
+            commit: attempt.commit || null,
+            card_id: attempt.card_id || null,
+        };
+        delete memory.failures[attempt.method];
+    }
+    else if (!attempt.ok) {
+        const prev = memory.failures[attempt.method];
+        memory.failures[attempt.method] = {
+            count: (prev?.count || 0) + 1,
+            last_kind: attempt.kind || null,
+            last_error: attempt.error ? attempt.error.slice(0, 400) : null,
+            last_at: at,
+            wrong_method: Boolean(wrongMethod),
+        };
+    }
+    saveMemory(memory);
+    return memory;
+}
+export function setExplicitProfile(projectPath, explicit) {
+    const memory = loadMemory(projectPath);
+    memory.explicit = { ...explicit, set_at: new Date().toISOString() };
+    // A human or IDE agent just told us how to deploy: earlier failures of that method are no longer a reason to avoid it.
+    delete memory.failures[explicit.method];
+    saveMemory(memory);
+    return memory;
+}
+export function setCardState(projectPath, cardId, state) {
+    const memory = loadMemory(projectPath);
+    if (state)
+        memory.cards[cardId] = state;
+    else
+        delete memory.cards[cardId];
+    saveMemory(memory);
+}
+export function getCardState(projectPath, cardId) {
+    return loadMemory(projectPath).cards[cardId] || null;
+}
+export function addPendingVerification(projectPath, pending) {
+    const memory = loadMemory(projectPath);
+    memory.pending = memory.pending.filter((p) => p.card_id !== pending.card_id);
+    memory.pending.push(pending);
+    saveMemory(memory);
+}
+export function removePendingVerification(projectPath, cardId) {
+    const memory = loadMemory(projectPath);
+    const next = memory.pending.filter((p) => p.card_id !== cardId);
+    if (next.length !== memory.pending.length) {
+        memory.pending = next;
+        saveMemory(memory);
+    }
+}