@agent-deck/backend 1.2.9 → 1.3.0

package/dist/mcp-server.js

@@ -10,12 +10,10 @@ const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const shared_1 = require("@agent-deck/shared");
 const express_1 = __importDefault(require("express"));
 const node_crypto_1 = require("node:crypto");
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-const zod_1 = require("zod");
-const repo_deck_1 = require("./scope/repo-deck");
 const version_1 = require("./lib/version");
 const mcp_session_binding_1 = require("./mcp-session-binding");
+const register_1 = require("./mcp-tools/register");
+const profile_1 = require("./mcp-tools/profile");
 const agentClientHeaders = {
     [shared_1.AGENT_DECK_CLIENT_HEADER]: shared_1.AGENT_DECK_AGENT_CLIENT,
     Accept: 'application/json',
@@ -24,21 +22,26 @@ class AgentDeckMCPServer {
     port;
     app;
     backendUrl;
+    toolProfile;
     sessions = new Map();
     /** Set only while registerTools/registerResources run for a new session server. */
     mcpServerForRegistration;
     /** Per-session workspace + optional deck override (see mcp-session-binding.ts). */
     sessionBinding;
     activeSessionId;
+    /** Session badge from the backend registry (POST /api/scope/live-display response). */
+    badgeBySession = new Map();
+    lastTouchAtMs = new Map();
     get server() {
         if (!this.mcpServerForRegistration) {
             throw new Error('Internal: MCP server not in registration context');
         }
         return this.mcpServerForRegistration;
     }
-    constructor(port = 3001, backendUrl = 'http://localhost:8000') {
+    constructor(port = 3001, backendUrl = 'http://localhost:8000', toolProfile) {
         this.port = port;
         this.backendUrl = backendUrl;
+        this.toolProfile = toolProfile ?? (0, profile_1.resolveMcpToolProfile)();
         this.app = (0, express_1.default)();
         this.app.use(express_1.default.json());
         this.setupRoutes();
@@ -77,18 +80,22 @@ class AgentDeckMCPServer {
         }
         return body.data;
     }
-    async buildBindingPayload(sessionId, manifestDeckId) {
+    async buildBindingPayload(sessionId) {
         const snapshot = this.sessionBinding.getBinding(sessionId);
         const deck = await this.callBackendAPI('/api/scope/deck');
+        const badge = this.badgeBySession.get(sessionId);
+        const cardCounts = deck ? (0, shared_1.countDeckCards)(deck) : { mcp: 0, credentials: 0, playbooks: 0 };
         return {
             workspaceRoot: snapshot.workspaceRoot,
             deck_id: deck?.id,
             deck_name: deck?.name,
-            deck_source: (0, mcp_session_binding_1.resolveDeckBindingSource)(snapshot, manifestDeckId),
+            deck_source: (0, mcp_session_binding_1.resolveDeckBindingSource)(snapshot),
             session_deck_override: this.sessionBinding.hasSessionDeckOverride(sessionId),
+            badge,
+            display_summary: (0, shared_1.formatDisplayLine)(deck?.name ?? null, cardCounts, { badge }),
         };
     }
-    async registerLiveDisplay(sessionId, manifestDeckId) {
+    async registerLiveDisplay(sessionId) {
         const snapshot = this.sessionBinding.getBinding(sessionId);
         if (!snapshot.workspaceRoot) {
             return;
@@ -97,7 +104,8 @@ class AgentDeckMCPServer {
         if (!deck?.id || !deck?.name) {
             return;
         }
-        await this.callBackendAPI('/api/scope/live-display', {
+        const clientName = this.sessions.get(sessionId)?.server.server.getClientVersion()?.name;
+        const result = await this.callBackendAPI('/api/scope/live-display', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
@@ -105,11 +113,32 @@ class AgentDeckMCPServer {
                 workspaceRoot: snapshot.workspaceRoot,
                 deckId: deck.id,
                 deckName: deck.name,
-                source: (0, mcp_session_binding_1.resolveDeckBindingSource)(snapshot, manifestDeckId),
+                source: (0, mcp_session_binding_1.resolveDeckBindingSource)(snapshot),
+                clientName,
                 cardCounts: (0, shared_1.countDeckCards)(deck),
                 updatedAt: new Date().toISOString(),
             }),
         });
+        if (result && typeof result.badge === 'string') {
+            this.badgeBySession.set(sessionId, result.badge);
+        }
+    }
+    static TOUCH_DEBOUNCE_MS = 5_000;
+    /** Fire-and-forget lastActivityAt bump; only for sessions the registry knows. */
+    touchLiveDisplay(sessionId) {
+        if (!this.badgeBySession.has(sessionId)) {
+            return;
+        }
+        const now = Date.now();
+        if (now - (this.lastTouchAtMs.get(sessionId) ?? 0) < AgentDeckMCPServer.TOUCH_DEBOUNCE_MS) {
+            return;
+        }
+        this.lastTouchAtMs.set(sessionId, now);
+        void this.callBackendAPI(`/api/scope/live-display/${encodeURIComponent(sessionId)}/touch`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ at: new Date().toISOString() }),
+        }).catch(() => { });
     }
     async unregisterLiveDisplay(sessionId) {
         try {
@@ -180,824 +209,21 @@ class AgentDeckMCPServer {
         this.server.registerTool(name, config, handler);
     }
     setupTools() {
-        this.registerTool("bind_workspace", {
-            title: "Bind Workspace",
-            description: "Bind this MCP session to a workspace root. Pass deckId for a session-only deck override (same path, different concurrent agents). Without deckId, uses .agent-deck/deck.yaml when present.",
-            inputSchema: {
-                workspaceRoot: zod_1.z.string(),
-                deckId: zod_1.z.string().uuid().optional(),
-            },
-        }, async ({ workspaceRoot, deckId }) => {
-            try {
-                const sessionId = this.getSessionId();
-                this.sessionBinding.setWorkspace(sessionId, workspaceRoot);
-                if (deckId) {
-                    const deck = await this.fetchDeck(deckId);
-                    this.sessionBinding.setDeckId(sessionId, deckId);
-                    const payload = await this.buildBindingPayload(sessionId);
-                    await this.registerLiveDisplay(sessionId);
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    ...payload,
-                                    deck_name: deck.name,
-                                    message: 'Session bound with deck override. .agent-deck/deck.yaml is unchanged; other MCP sessions can use a different deck at the same path.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                this.sessionBinding.clearDeckId(sessionId);
-                const resolved = await fetch(`${this.backendUrl}/api/scope/resolve`, {
-                    method: 'POST',
-                    headers: { ...agentClientHeaders, 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ workspaceRoot }),
-                });
-                const body = (await resolved.json());
-                if (!body.success || !body.data) {
-                    throw new Error(body.error ??
-                        'Failed to resolve workspace deck. Pass deckId to bind without deck.yaml, or call setup_repo_deck.');
-                }
-                const { data } = body;
-                const payload = await this.buildBindingPayload(sessionId, data.manifest.deck_id);
-                await this.registerLiveDisplay(sessionId, data.manifest.deck_id);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                ...payload,
-                                manifestPath: data.manifestPath,
-                                message: 'Session bound via .agent-deck/deck.yaml.',
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                const message = String(error);
-                const hint = message.includes('deck.yaml') || message.includes('No .agent-deck')
-                    ? ' Pass deckId on bind_workspace, call setup_repo_deck, or get_repo_deck_status to diagnose.'
-                    : '';
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: message + hint }, null, 2) }],
-                };
-            }
-        });
-        this.registerTool("switch_bound_deck", {
-            title: "Switch Bound Deck",
-            description: "Switch the deck for this MCP session only. Does not modify .agent-deck/deck.yaml. Use when multiple agent sessions share the same workspace path.",
-            inputSchema: { deckId: zod_1.z.string().uuid() },
-        }, async ({ deckId }) => {
-            try {
-                const sessionId = this.getSessionId();
-                const deck = await this.fetchDeck(deckId);
-                this.sessionBinding.setDeckId(sessionId, deckId);
-                const payload = await this.buildBindingPayload(sessionId);
-                await this.registerLiveDisplay(sessionId);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                ...payload,
-                                deck_name: deck.name,
-                                message: 'Session deck switched. Other sessions and deck.yaml are unchanged.',
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("get_session_binding", {
-            title: "Get Session Binding",
-            description: "Show workspace and effective deck for this MCP session, including whether the deck comes from a session override or repo deck.yaml.",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const sessionId = this.getSessionId();
-                const snapshot = this.sessionBinding.getBinding(sessionId);
-                let manifestDeckId;
-                if (snapshot.workspaceRoot && !snapshot.deckSource) {
-                    const manifest = await (0, repo_deck_1.loadRepoDeckManifest)(snapshot.workspaceRoot);
-                    manifestDeckId = manifest?.deck_id;
-                }
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                const cardCounts = deck ? (0, shared_1.countDeckCards)(deck) : { mcp: 0, credentials: 0, playbooks: 0 };
-                const displaySummary = (0, shared_1.formatDisplayLine)(deck?.name ?? null, cardCounts);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                workspaceRoot: snapshot.workspaceRoot,
-                                session_deck_override: snapshot.deckId,
-                                session_deck_source: snapshot.deckSource,
-                                repo_manifest_deck_id: manifestDeckId,
-                                effective_deck_id: deck?.id,
-                                effective_deck_name: deck?.name,
-                                effective_deck_source: (0, mcp_session_binding_1.resolveDeckBindingSource)(snapshot, manifestDeckId),
-                                display_summary: displaySummary,
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("get_repo_deck_status", {
-            title: "Get Repo Deck Status",
-            description: "Check whether .agent-deck/deck.yaml exists in a workspace and whether it links to a valid deck",
-            inputSchema: { workspaceRoot: zod_1.z.string() },
-        }, async ({ workspaceRoot }) => {
-            try {
-                const filePath = (0, repo_deck_1.repoDeckManifestFilePath)(workspaceRoot);
-                const manifest = await (0, repo_deck_1.loadRepoDeckManifest)(workspaceRoot);
-                if (!manifest) {
-                    const decks = await this.callBackendAPI('/api/decks');
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    status: 'missing',
-                                    workspaceRoot,
-                                    expectedPath: shared_1.REPO_DECK_MANIFEST_PATH,
-                                    message: 'No .agent-deck/deck.yaml found. Use setup_repo_deck to create one.',
-                                    availableDecks: Array.isArray(decks)
-                                        ? decks.map((d) => ({ id: d.id, name: d.name }))
-                                        : decks,
-                                }, null, 2),
-                            }],
-                    };
-                }
-                const resolved = await fetch(`${this.backendUrl}/api/scope/resolve`, {
-                    method: 'POST',
-                    headers: { ...agentClientHeaders, 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ workspaceRoot }),
-                });
-                const body = (await resolved.json());
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                status: body.success ? 'ok' : 'invalid',
-                                workspaceRoot,
-                                filePath,
-                                manifest,
-                                deck: body.data?.deck,
-                                error: body.success ? undefined : body.error,
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
-                };
-            }
-        });
-        this.registerTool("setup_repo_deck", {
-            title: "Setup Repo Deck",
-            description: "Create or verify .agent-deck/deck.yaml in a repo. Links the workspace to an Agent Deck by deck_id. Optionally writes the file.",
-            inputSchema: {
-                workspaceRoot: zod_1.z.string(),
-                deckId: zod_1.z.string().uuid().optional(),
-                deckName: zod_1.z.string().optional(),
-                writeFile: zod_1.z.boolean().optional(),
-            },
-        }, async ({ workspaceRoot, deckId, deckName, writeFile = true }) => {
-            try {
-                const sessionId = this.getSessionId();
-                const existing = await (0, repo_deck_1.loadRepoDeckManifest)(workspaceRoot);
-                if (existing) {
-                    this.sessionBinding.setWorkspace(sessionId, workspaceRoot);
-                    const resolved = await fetch(`${this.backendUrl}/api/scope/resolve`, {
-                        method: 'POST',
-                        headers: { ...agentClientHeaders, 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ workspaceRoot }),
-                    });
-                    const body = (await resolved.json());
-                    if (!body.success || !body.data) {
-                        throw new Error(body.error ?? 'Existing manifest is invalid');
-                    }
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    status: 'existing',
-                                    workspaceRoot,
-                                    manifestPath: body.data.manifestPath,
-                                    deck_id: body.data.manifest.deck_id,
-                                    deck_name: body.data.deck.name,
-                                    message: 'Workspace already linked. Session bound to this deck.',
-                                }, null, 2),
-                            }],
-                    };
-                }
-                if (!deckId) {
-                    const decks = await this.callBackendAPI('/api/decks');
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify({
-                                    status: 'needs_deck_id',
-                                    workspaceRoot,
-                                    expectedPath: shared_1.REPO_DECK_MANIFEST_PATH,
-                                    message: 'Pick a deck id from the dashboard (My Decks → copy icon) and call setup_repo_deck again with deckId.',
-                                    availableDecks: Array.isArray(decks)
-                                        ? decks.map((d) => ({ id: d.id, name: d.name }))
-                                        : decks,
-                                }, null, 2),
-                            }],
-                    };
-                }
-                const deck = await this.callBackendAPI(`/api/decks/${deckId}`);
-                if (!deck?.id) {
-                    throw new Error(`Deck not found: ${deckId}`);
-                }
-                const content = (0, repo_deck_1.formatRepoDeckManifest)(deckId, deckName ?? deck.name);
-                const dirPath = node_path_1.default.join(node_path_1.default.resolve(workspaceRoot), '.agent-deck');
-                const filePath = (0, repo_deck_1.repoDeckManifestFilePath)(workspaceRoot);
-                if (writeFile) {
-                    await promises_1.default.mkdir(dirPath, { recursive: true });
-                    await promises_1.default.writeFile(filePath, content, 'utf8');
-                }
-                this.sessionBinding.setWorkspace(sessionId, workspaceRoot);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                status: writeFile ? 'created' : 'preview',
-                                workspaceRoot,
-                                filePath,
-                                deck_id: deckId,
-                                deck_name: deck.name,
-                                manifestContent: content,
-                                message: writeFile
-                                    ? 'Created .agent-deck/deck.yaml and bound this session to the deck.'
-                                    : 'Preview only — set writeFile true to write the file.',
-                            }, null, 2),
-                        }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
-                };
-            }
-        });
-        // Get all decks (metadata only; credentials stripped unless bound)
-        this.registerTool("get_decks", {
-            title: "Get Decks",
-            description: "Get all available decks from Agent Deck",
-            inputSchema: {}
-        }, async () => {
-            try {
-                const decks = await this.callBackendAPI('/api/decks');
-                return {
-                    content: [{ type: "text", text: JSON.stringify(decks, null, 2) }]
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }]
-                };
-            }
-        });
-        this.registerTool("get_bound_deck", {
-            title: "Get Bound Deck",
-            description: "Get the deck bound to this session (session deckId override, env, or .agent-deck/deck.yaml)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                return {
-                    content: [{ type: "text", text: JSON.stringify(deck, null, 2) }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
-                };
-            }
-        });
-        // Deprecated alias
-        this.registerTool("get_active_deck", {
-            title: "Get Active Deck (deprecated)",
-            description: "Deprecated — use get_bound_deck. Returns the workspace-bound deck.",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                return {
-                    content: [{ type: "text", text: JSON.stringify(deck, null, 2) }],
-                };
-            }
-            catch (error) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }],
-                };
-            }
-        });
-        this.registerTool("list_bound_deck_services", {
-            title: "List Bound Deck Services",
-            description: "List MCP services on the workspace-bound deck",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                const services = deck?.services ?? [];
-                return { content: [{ type: "text", text: JSON.stringify(services, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_active_deck_services", {
-            title: "List Active Deck Services (deprecated)",
-            description: "Deprecated — use list_bound_deck_services",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const deck = await this.callBackendAPI('/api/scope/deck');
-                const services = deck?.services ?? [];
-                return { content: [{ type: "text", text: JSON.stringify(services, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_bound_deck_credentials", {
-            title: "List Bound Deck Credentials",
-            description: "List API key metadata on the workspace-bound deck",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const credentials = await this.callBackendAPI('/api/credentials');
-                return { content: [{ type: "text", text: JSON.stringify(credentials, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_active_deck_credentials", {
-            title: "List Active Deck Credentials (deprecated)",
-            description: "Deprecated — use list_bound_deck_credentials",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const credentials = await this.callBackendAPI('/api/credentials');
-                return { content: [{ type: "text", text: JSON.stringify(credentials, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_playbooks", {
-            title: "List Playbooks",
-            description: "List playbook cards on the bound deck (id, title, triggers)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const playbooks = await this.callBackendAPI('/api/playbooks/summaries');
-                return { content: [{ type: "text", text: JSON.stringify(playbooks, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("get_playbook", {
-            title: "Get Playbook",
-            description: "Get full markdown body, metadata, and dependencies for a playbook card by id",
-            inputSchema: { playbook_id: zod_1.z.string() },
-        }, async ({ playbook_id }) => {
-            try {
-                const playbook = await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`);
-                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("register_playbook", {
-            title: "Register Playbook",
-            description: "Create a playbook card, auto-detect API key and MCP dependencies from the content, and add it to the bound deck by default",
-            inputSchema: {
-                title: zod_1.z.string(),
-                body: zod_1.z.string(),
-                triggers: zod_1.z.array(zod_1.z.string()).optional(),
-                playbook_id: zod_1.z.string().optional(),
-                exec: zod_1.z.string().optional(),
-                skill: zod_1.z.string().optional(),
-                depends_on_credential_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                depends_on_service_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                add_to_bound_deck: zod_1.z.boolean().optional(),
-                auto_detect_dependencies: zod_1.z.boolean().optional(),
-            },
-        }, async (args) => {
-            try {
-                const playbook = await this.callBackendAPI("/api/playbooks", {
-                    method: "POST",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        title: args.title,
-                        body: args.body,
-                        triggers: args.triggers,
-                        id: args.playbook_id,
-                        exec: args.exec,
-                        skill: args.skill,
-                        dependsOnCredentialIds: args.depends_on_credential_ids,
-                        dependsOnServiceIds: args.depends_on_service_ids,
-                        addToBoundDeck: args.add_to_bound_deck,
-                        autoDetectDependencies: args.auto_detect_dependencies,
-                    }),
-                });
-                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("update_playbook", {
-            title: "Update Playbook",
-            description: "Update a playbook on the bound deck. Dependencies are re-detected from the updated content by default.",
-            inputSchema: {
-                playbook_id: zod_1.z.string(),
-                title: zod_1.z.string().optional(),
-                body: zod_1.z.string().optional(),
-                triggers: zod_1.z.array(zod_1.z.string()).optional(),
-                exec: zod_1.z.string().optional(),
-                skill: zod_1.z.string().optional(),
-                depends_on_credential_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                depends_on_service_ids: zod_1.z.array(zod_1.z.string()).optional(),
-                auto_detect_dependencies: zod_1.z.boolean().optional(),
-            },
-        }, async ({ playbook_id, ...args }) => {
-            try {
-                const playbook = await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`, {
-                    method: "PUT",
-                    headers: { "Content-Type": "application/json" },
-                    body: JSON.stringify({
-                        title: args.title,
-                        body: args.body,
-                        triggers: args.triggers,
-                        exec: args.exec,
-                        skill: args.skill,
-                        dependsOnCredentialIds: args.depends_on_credential_ids,
-                        dependsOnServiceIds: args.depends_on_service_ids,
-                        autoDetectDependencies: args.auto_detect_dependencies,
-                    }),
-                });
-                return { content: [{ type: "text", text: JSON.stringify(playbook, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        this.registerTool("list_collection_services", {
-            title: "List Collection Services",
-            description: "List all registered MCP services in the collection (metadata only)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const services = await this.callBackendAPI('/api/services');
-                return this.toolResult(services);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("register_service", {
-            title: "Register Service",
-            description: "Register an MCP service in the collection. Optionally add it to the bound deck. OAuth setup still requires the dashboard browser flow.",
-            inputSchema: {
-                name: zod_1.z.string(),
-                type: zod_1.z.enum(['mcp', 'a2a', 'local-mcp']),
-                url: zod_1.z.string(),
-                description: zod_1.z.string().optional(),
-                cardColor: zod_1.z.string().optional(),
-                credentialId: zod_1.z.string().optional(),
-                headers: zod_1.z.record(zod_1.z.string()).optional(),
-                localCommand: zod_1.z.string().optional(),
-                localArgs: zod_1.z.array(zod_1.z.string()).optional(),
-                localWorkingDir: zod_1.z.string().optional(),
-                localEnv: zod_1.z.record(zod_1.z.string()).optional(),
-                add_to_bound_deck: zod_1.z.boolean().optional(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async (args) => {
-            try {
-                const { add_to_bound_deck, position, ...serviceInput } = args;
-                const service = await this.callBackendAPI('/api/services', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(serviceInput),
-                });
-                if (add_to_bound_deck !== false) {
-                    const deckId = await this.getBoundDeckId();
-                    await this.callBackendAPI(`/api/decks/${deckId}/services`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ serviceId: service.id, position }),
-                    });
-                }
-                return this.toolResult(service);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("update_service", {
-            title: "Update Service",
-            description: "Update MCP service metadata in the collection (not OAuth tokens — use dashboard for OAuth)",
-            inputSchema: {
-                service_id: zod_1.z.string(),
-                name: zod_1.z.string().optional(),
-                type: zod_1.z.enum(['mcp', 'a2a', 'local-mcp']).optional(),
-                url: zod_1.z.string().optional(),
-                description: zod_1.z.string().optional(),
-                cardColor: zod_1.z.string().optional(),
-                credentialId: zod_1.z.string().optional(),
-                headers: zod_1.z.record(zod_1.z.string()).optional(),
-                localCommand: zod_1.z.string().optional(),
-                localArgs: zod_1.z.array(zod_1.z.string()).optional(),
-                localWorkingDir: zod_1.z.string().optional(),
-                localEnv: zod_1.z.record(zod_1.z.string()).optional(),
-            },
-        }, async ({ service_id, ...updates }) => {
-            try {
-                const service = await this.callBackendAPI(`/api/services/${service_id}`, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(updates),
-                });
-                return this.toolResult(service);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("delete_service", {
-            title: "Delete Service",
-            description: "Remove an MCP service from the collection entirely",
-            inputSchema: { service_id: zod_1.z.string() },
-        }, async ({ service_id }) => {
-            try {
-                await this.callBackendAPI(`/api/services/${service_id}`, { method: 'DELETE' });
-                return this.toolResult({ success: true, service_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("add_service_to_bound_deck", {
-            title: "Add Service To Bound Deck",
-            description: "Link an existing MCP service from the collection onto the bound deck",
-            inputSchema: {
-                service_id: zod_1.z.string(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async ({ service_id, position }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/services`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ serviceId: service_id, position }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, service_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("remove_service_from_bound_deck", {
-            title: "Remove Service From Bound Deck",
-            description: "Unlink an MCP service from the bound deck (service stays in the collection)",
-            inputSchema: { service_id: zod_1.z.string() },
-        }, async ({ service_id }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/services`, {
-                    method: 'DELETE',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ serviceId: service_id }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, service_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("update_service_tool_settings", {
-            title: "Update Service Tool Settings",
-            description: "Enable or disable individual tools for an MCP service on the bound deck",
-            inputSchema: {
-                service_id: zod_1.z.string(),
-                disabled_tools: zod_1.z.array(zod_1.z.string()),
-            },
-        }, async ({ service_id, disabled_tools }) => {
-            try {
-                const service = await this.callBackendAPI(`/api/services/${service_id}/tool-settings`, {
-                    method: 'PUT',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ disabledTools: disabled_tools }),
-                });
-                return this.toolResult(service);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("list_collection_credentials", {
-            title: "List Collection Credentials",
-            description: "List all API key metadata in the collection (no secret values). Use credential ids to link keys to the bound deck after the user stores the secret in the dashboard.",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const credentials = await this.callBackendAPI('/api/credentials/collection');
-                return this.toolResult(credentials);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("add_credential_to_bound_deck", {
-            title: "Add Credential To Bound Deck",
-            description: "Link an existing API key (by credential id) to the bound deck. The secret must already be stored via the dashboard or CLI.",
-            inputSchema: {
-                credential_id: zod_1.z.string(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async ({ credential_id, position }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/credentials`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ credentialId: credential_id, position }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, credential_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("remove_credential_from_bound_deck", {
-            title: "Remove Credential From Bound Deck",
-            description: "Unlink an API key from the bound deck (credential stays in the vault)",
-            inputSchema: { credential_id: zod_1.z.string() },
-        }, async ({ credential_id }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/credentials`, {
-                    method: 'DELETE',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ credentialId: credential_id }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, credential_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("list_collection_playbooks", {
-            title: "List Collection Playbooks",
-            description: "List all playbook cards in the collection (for linking existing playbooks to the bound deck)",
-            inputSchema: {},
-        }, async () => {
-            try {
-                const playbooks = await this.callBackendAPI('/api/playbooks/collection');
-                return this.toolResult(playbooks);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("add_playbook_to_bound_deck", {
-            title: "Add Playbook To Bound Deck",
-            description: "Link an existing playbook card from the collection onto the bound deck",
-            inputSchema: {
-                playbook_id: zod_1.z.string(),
-                position: zod_1.z.number().optional(),
-            },
-        }, async ({ playbook_id, position }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/playbooks`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ playbookId: playbook_id, position }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, playbook_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("remove_playbook_from_bound_deck", {
-            title: "Remove Playbook From Bound Deck",
-            description: "Unlink a playbook from the bound deck (playbook stays in the collection)",
-            inputSchema: { playbook_id: zod_1.z.string() },
-        }, async ({ playbook_id }) => {
-            try {
-                const deckId = await this.getBoundDeckId();
-                await this.callBackendAPI(`/api/decks/${deckId}/playbooks`, {
-                    method: 'DELETE',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ playbookId: playbook_id }),
-                });
-                return this.toolResult({ success: true, deck_id: deckId, playbook_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("delete_playbook", {
-            title: "Delete Playbook",
-            description: "Delete a playbook from the collection (must be on the bound deck for agent clients)",
-            inputSchema: { playbook_id: zod_1.z.string() },
-        }, async ({ playbook_id }) => {
-            try {
-                await this.callBackendAPI(`/api/playbooks/${encodeURIComponent(playbook_id)}`, {
-                    method: 'DELETE',
-                });
-                return this.toolResult({ success: true, playbook_id });
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        this.registerTool("create_deck", {
-            title: "Create Deck",
-            description: "Create a new deck in Agent Deck",
-            inputSchema: {
-                name: zod_1.z.string(),
-                description: zod_1.z.string().optional(),
-            },
-        }, async ({ name, description }) => {
-            try {
-                const deck = await this.callBackendAPI('/api/decks', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, description }),
-                });
-                return this.toolResult(deck);
-            }
-            catch (error) {
-                return this.toolError(error);
-            }
-        });
-        // Remove duplicate old tools block - list_service_tools follows
-        this.registerTool("list_service_tools", {
-            title: "List Service Tools",
-            description: "List all available tools for a specific service in the active deck",
-            inputSchema: { serviceId: zod_1.z.string() }
-        }, async ({ serviceId }) => {
-            try {
-                const tools = await this.callBackendAPI(`/api/services/${serviceId}/tools`);
-                return { content: [{ type: "text", text: JSON.stringify(tools, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
-        });
-        // Call a tool on a service in the active deck
-        this.registerTool("call_service_tool", {
-            title: "Call Service Tool",
-            description: "Call a tool on a service from the active deck",
-            inputSchema: {
-                serviceId: zod_1.z.string(),
-                toolName: zod_1.z.string(),
-                arguments: zod_1.z.union([zod_1.z.record(zod_1.z.any()), zod_1.z.string()]).optional()
-            }
-        }, async ({ serviceId, toolName, arguments: args = {} }) => {
-            try {
-                // Support both object and JSON string inputs for arguments
-                let normalizedArgs = args;
-                if (typeof normalizedArgs === 'string' && normalizedArgs.length > 0) {
-                    try {
-                        normalizedArgs = JSON.parse(normalizedArgs);
-                    }
-                    catch (e) {
-                        return { content: [{ type: "text", text: JSON.stringify({ error: `Invalid JSON in arguments: ${String(e)}` }, null, 2) }] };
-                    }
-                }
-                const res = await fetch(`${this.backendUrl}/api/services/${serviceId}/call`, {
-                    method: 'POST',
-                    headers: { ...this.getAgentHeaders(), 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ toolName, arguments: normalizedArgs ?? {} })
-                });
-                if (!res.ok) {
-                    const text = await res.text();
-                    throw new Error(`Backend API error ${res.status}: ${text}`);
-                }
-                const body = await res.json();
-                const data = (body && body.success) ? (body.data ?? body.result ?? body) : body;
-                return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: JSON.stringify({ error: String(error) }, null, 2) }] };
-            }
+        (0, register_1.registerMcpTools)({
+            registerTool: (name, config, handler) => this.registerTool(name, config, handler),
+            profile: this.toolProfile,
+            getSessionId: () => this.getSessionId(),
+            getAgentHeaders: () => this.getAgentHeaders(),
+            getBoundDeckId: () => this.getBoundDeckId(),
+            callBackendAPI: (endpoint, init) => this.callBackendAPI(endpoint, init),
+            fetchDeck: (deckId) => this.fetchDeck(deckId),
+            buildBindingPayload: (sessionId) => this.buildBindingPayload(sessionId),
+            registerLiveDisplay: (sessionId) => this.registerLiveDisplay(sessionId),
+            sessionBinding: this.sessionBinding,
+            badgeBySession: this.badgeBySession,
+            backendUrl: this.backendUrl,
+            toolResult: (data) => this.toolResult(data),
+            toolError: (error) => this.toolError(error),
         });
     }
     setupResources() {
@@ -1125,7 +351,7 @@ class AgentDeckMCPServer {
             }
         });
         this.server.resource("bound_deck", "agent-deck://bound-deck", {
-            description: "Deck bound via .agent-deck/deck.yaml in the workspace",
+            description: "Deck bound to this MCP session",
             mimeType: "application/json"
         }, async () => {
             try {
@@ -1213,7 +439,8 @@ class AgentDeckMCPServer {
             res.json({
                 status: 'ok',
                 service: 'agent-deck-mcp-server',
-                backendUrl: this.backendUrl
+                backendUrl: this.backendUrl,
+                toolProfile: this.toolProfile,
             });
         });
         // Backend connectivity check
@@ -1244,8 +471,9 @@ class AgentDeckMCPServer {
     async handleMcpPost(req, res) {
         const sessionIdHeader = this.getSessionIdHeader(req);
         const existing = sessionIdHeader ? this.sessions.get(sessionIdHeader) : undefined;
-        if (existing) {
+        if (existing && sessionIdHeader) {
             this.activeSessionId = sessionIdHeader;
+            this.touchLiveDisplay(sessionIdHeader);
             await existing.transport.handleRequest(req, res, req.body);
             return;
         }
@@ -1277,6 +505,8 @@ class AgentDeckMCPServer {
             if (sessionId) {
                 this.sessions.delete(sessionId);
                 this.sessionBinding.clearSession(sessionId);
+                this.badgeBySession.delete(sessionId);
+                this.lastTouchAtMs.delete(sessionId);
                 void this.unregisterLiveDisplay(sessionId);
             }
         };
@@ -1299,6 +529,7 @@ class AgentDeckMCPServer {
             return;
         }
         this.activeSessionId = sessionId;
+        this.touchLiveDisplay(sessionId);
         await session.transport.handleRequest(req, res);
     }
     async start() {
@@ -1308,12 +539,10 @@ class AgentDeckMCPServer {
             this.app.listen(this.port, () => {
                 console.log(`✅ Agent Deck MCP Server is ready to accept connections`);
                 console.log(`📋 Available tools:`);
-                console.log(`   - bind_workspace: Bind session to workspace; optional deckId override`);
+                console.log(`   - bind_workspace: Bind session to workspace + deck (deckId required)`);
                 console.log(`   - switch_bound_deck: Switch deck for this session only`);
                 console.log(`   - get_session_binding: Show session workspace + effective deck`);
-                console.log(`   - get_repo_deck_status: Check repo deck manifest`);
-                console.log(`   - setup_repo_deck: Create .agent-deck/deck.yaml for a repo`);
-                console.log(`   - get_bound_deck: Get workspace-bound deck`);
+                console.log(`   - get_bound_deck: Get session-bound deck`);
                 console.log(`   - list_service_tools: List tools for a specific service`);
                 console.log(`   - call_service_tool: Call a tool on a service`);
                 console.log(`📋 Available resources:`);