@gethmy/mcp 2.2.0 → 2.2.1

package/dist/lib/__tests__/auto-session.test.js

@@ -29,16 +29,16 @@ describe("auto-start", () => {
         await trackActivity(CARD_A, { autoStart: true, client: client });
         expect(client.startAgentSession).toHaveBeenCalledTimes(1);
         expect(client.startAgentSession).toHaveBeenCalledWith(CARD_A, {
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
             status: "working",
         });
         expect(getActiveSessions().size).toBe(1);
         const session = getActiveSessions().get(CARD_A);
         expect(session).toBeDefined();
         expect(session.isExplicit).toBe(false);
-        expect(session.agentIdentifier).toBe("auto");
-        expect(session.agentName).toBe("Auto-detected Agent");
+        expect(session.agentIdentifier).toBe("unknown");
+        expect(session.agentName).toBe("Unknown Agent");
     });
     test("does NOT trigger on autoStart=false", async () => {
         const client = makeMockClient();
@@ -68,7 +68,7 @@ describe("auto-start", () => {
         await trackActivity(CARD_A, { autoStart: true, client: client });
         // Should still be tracked despite API error
         expect(getActiveSessions().size).toBe(1);
-        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("auto");
+        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("unknown");
     });
     test("uses clientGetter when no client in options", async () => {
         const client = makeMockClient();
@@ -222,8 +222,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - INACTIVITY_TIMEOUT_MS - 1000,
             lastActivityAt: Date.now() - INACTIVITY_TIMEOUT_MS - 1000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         // autoEndSession is fire-and-forget in checkInactivity, wait for it
@@ -241,8 +241,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(), // just now — well within timeout
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         expect(client.endAgentSession).not.toHaveBeenCalled();
@@ -273,8 +273,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             lastActivityAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // CARD_B — still active
         getActiveSessions().set(CARD_B, {
@@ -282,8 +282,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - 1000,
             lastActivityAt: Date.now() - 1000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // CARD_C — timed out but explicit
         getActiveSessions().set(CARD_C, {
@@ -312,8 +312,8 @@ describe("inactivity timeout", () => {
             startedAt: 0,
             lastActivityAt: 0,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // Should not throw
         checkInactivity();
@@ -330,8 +330,8 @@ describe("inactivity timeout", () => {
             startedAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             lastActivityAt: Date.now() - INACTIVITY_TIMEOUT_MS - 5000,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // Refresh activity
         await trackActivity(CARD_A, { autoStart: false });
@@ -351,8 +351,8 @@ describe("markExplicit", () => {
         expect(getActiveSessions().get(CARD_A).isExplicit).toBe(false);
         markExplicit(CARD_A);
         expect(getActiveSessions().get(CARD_A).isExplicit).toBe(true);
-        // agentIdentifier should remain "auto" since it was auto-started
-        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("auto");
+        // agentIdentifier should remain "unknown" since no clientInfo was provided
+        expect(getActiveSessions().get(CARD_A).agentIdentifier).toBe("unknown");
     });
     test("creates new tracking entry for unknown card", () => {
         initAutoSession(mock(async () => { }), () => makeMockClient());
@@ -406,8 +406,8 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         await shutdownAllSessions();
         expect(client.endAgentSession).toHaveBeenCalledWith(CARD_A, {
@@ -425,8 +425,8 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         getActiveSessions().set(CARD_B, {
             cardId: CARD_B,
@@ -449,8 +449,8 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         // Should not throw
         await shutdownAllSessions();
@@ -473,16 +473,16 @@ describe("shutdown", () => {
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         getActiveSessions().set(CARD_B, {
             cardId: CARD_B,
             startedAt: Date.now(),
             lastActivityAt: Date.now(),
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         await shutdownAllSessions();
         // Both should be removed from tracking despite first API error
@@ -595,8 +595,8 @@ describe("edge cases", () => {
             startedAt: 0,
             lastActivityAt: 0,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         await new Promise((r) => setTimeout(r, 50));
@@ -615,8 +615,8 @@ describe("edge cases", () => {
             startedAt: 0,
             lastActivityAt: 0,
             isExplicit: false,
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier: "unknown",
+            agentName: "Unknown Agent",
         });
         checkInactivity();
         await new Promise((r) => setTimeout(r, 50));

package/dist/lib/api-client.js

@@ -536,6 +536,122 @@ export class HarmonyApiClient {
     async generateApiKey(name) {
         return this.request("POST", "/api-keys", { name });
     }
+    // ============ PROMPT GENERATION ============
+    /**
+     * Generate a prompt for a card with full memory context assembly.
+     *
+     * This is the shared entry point for prompt generation — used by the MCP
+     * server tool handler and the agent daemon. It fetches the card, assembles
+     * relevant memories, and produces a role-framed prompt.
+     */
+    async generateCardPrompt(options) {
+        const { assembleContext, cacheManifest, generatePrompt } = await loadPromptModules();
+        // Fetch card data
+        const cardResult = await this.getCard(options.cardId);
+        const cardData = cardResult.card;
+        // Try to get column info
+        let columnData = null;
+        const projectIdForBoard = options.projectId || cardData.project_id;
+        if (projectIdForBoard) {
+            try {
+                const board = await this.getBoard(projectIdForBoard, { summary: true });
+                const column = board.columns.find((col) => col.id === cardData.column_id);
+                if (column) {
+                    columnData = { name: column.name };
+                }
+            }
+            catch {
+                // Column info not available, continue without it
+            }
+        }
+        const variant = options.variant || "execute";
+        // Assemble memory context
+        let assembledContextStr;
+        let assemblyId;
+        let memories;
+        try {
+            if (options.workspaceId && cardData.title) {
+                const cardLabels = (cardData.labels || []).map((l) => l.name);
+                const taskContext = [cardData.title, cardData.description || ""]
+                    .filter(Boolean)
+                    .join(" ");
+                const assembled = await assembleContext({
+                    workspaceId: options.workspaceId,
+                    projectId: options.projectId,
+                    taskContext,
+                    cardLabels,
+                    cardId: cardData.id,
+                    client: this,
+                });
+                if (assembled.context) {
+                    assembledContextStr = assembled.context;
+                    assemblyId = assembled.manifest.assemblyId;
+                    cacheManifest(assembled.manifest);
+                }
+            }
+        }
+        catch (err) {
+            // Context assembly failed, try legacy fallback
+            const msg = err instanceof Error ? err.message : String(err);
+            console.debug(`[generateCardPrompt] Context assembly failed: ${msg}`);
+            try {
+                if (options.workspaceId && cardData.title) {
+                    const memoryResult = await this.searchMemoryEntities(options.workspaceId, cardData.title, {
+                        project_id: options.projectId,
+                        limit: 5,
+                    });
+                    if (memoryResult.entities?.length > 0) {
+                        memories = memoryResult.entities.map((e) => ({
+                            id: e.id,
+                            type: e.type,
+                            title: e.title,
+                            content: e.content,
+                            confidence: e.confidence,
+                            tags: e.tags || [],
+                        }));
+                    }
+                }
+            }
+            catch (fallbackErr) {
+                const fallbackMsg = fallbackErr instanceof Error
+                    ? fallbackErr.message
+                    : String(fallbackErr);
+                console.debug(`[generateCardPrompt] Memory fallback also failed: ${fallbackMsg}`);
+            }
+        }
+        const result = generatePrompt({
+            card: cardData,
+            column: columnData,
+            variant,
+            contextOptions: options.contextOptions,
+            customConstraints: options.customConstraints,
+            memories,
+            assembledContext: assembledContextStr,
+            assemblyId,
+        });
+        return {
+            ...result,
+            cardId: cardData.id,
+            shortId: cardData.short_id,
+            title: cardData.title,
+        };
+    }
+}
+// Cached dynamic imports for context-assembly and prompt-builder
+let _promptModules = null;
+async function loadPromptModules() {
+    if (!_promptModules) {
+        const [ca, pb] = await Promise.all([
+            import("./context-assembly.js"),
+            import("./prompt-builder.js"),
+        ]);
+        _promptModules = {
+            assembleContext: ca.assembleContext,
+            cacheManifest: ca.cacheManifest,
+            generatePrompt: pb.generatePrompt,
+        };
+    }
+    return _promptModules;
 }
 // Singleton instance
 let client = null;

package/dist/lib/auto-session.js

@@ -4,7 +4,36 @@
  * Automatically detects agent session boundaries by monitoring tool calls.
  * Sessions auto-start when card-mutating tools are called, and auto-end
  * after 10 minutes of inactivity or when a different card is worked on.
+ *
+ * Agent identity is resolved from the MCP client's `initialize` handshake
+ * (clientInfo.name), so "Claude Code", "Cursor", "Windsurf", etc. are
+ * detected automatically — no hardcoded fallback needed.
  */
+/** Well-known MCP client names → human-friendly display names */
+const CLIENT_DISPLAY_NAMES = {
+    "claude-code": "Claude Code",
+    "claude-desktop": "Claude Desktop",
+    cursor: "Cursor",
+    windsurf: "Windsurf",
+    cline: "Cline",
+    continue: "Continue",
+    "codex-cli": "OpenAI Codex",
+    zed: "Zed",
+    "gemini-cli": "Gemini CLI",
+};
+/** Derive a slug-style identifier from a client name */
+function toIdentifier(name) {
+    return name.toLowerCase().replace(/\s+/g, "-");
+}
+/** Resolve agent identity from MCP client info */
+export function resolveAgentIdentity(info) {
+    if (!info?.name) {
+        return { agentIdentifier: "unknown", agentName: "Unknown Agent" };
+    }
+    const key = toIdentifier(info.name);
+    const displayName = CLIENT_DISPLAY_NAMES[key] ?? info.name; // use raw name if not in map
+    return { agentIdentifier: key, agentName: displayName };
+}
 /** Tools that trigger auto-start of a session */
 export const AUTO_START_TRIGGERS = new Set([
     "harmony_generate_prompt",
@@ -21,14 +50,17 @@ const activeSessions = new Map();
 let inactivityTimer = null;
 let endCallback = null;
 let clientGetter = null;
+let clientInfoGetter = null;
 /**
  * Initialize auto-session tracking.
  * @param callback Called when an auto-session ends (runs the learning pipeline)
  * @param getClient Function to get the current API client
+ * @param getClientInfo Function to get MCP client identity from the initialize handshake
  */
-export function initAutoSession(callback, getClient) {
+export function initAutoSession(callback, getClient, getClientInfo) {
     endCallback = callback;
     clientGetter = getClient;
+    clientInfoGetter = getClientInfo ?? null;
     if (inactivityTimer)
         clearInterval(inactivityTimer);
     inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
@@ -60,11 +92,14 @@ export async function trackActivity(cardId, options) {
     for (const otherCardId of toEnd) {
         await autoEndSession(client, otherCardId, "completed");
     }
+    // Resolve agent identity from MCP client info
+    const info = clientInfoGetter?.() ?? null;
+    const { agentIdentifier, agentName } = resolveAgentIdentity(info);
     // Start a new auto-session
     try {
         await client.startAgentSession(cardId, {
-            agentIdentifier: "auto",
-            agentName: "Auto-detected Agent",
+            agentIdentifier,
+            agentName,
             status: "working",
         });
     }
@@ -76,8 +111,8 @@ export async function trackActivity(cardId, options) {
         startedAt: now,
         lastActivityAt: now,
         isExplicit: false,
-        agentIdentifier: "auto",
-        agentName: "Auto-detected Agent",
+        agentIdentifier,
+        agentName,
     });
 }
 /**
@@ -134,6 +169,7 @@ export function destroyAutoSession() {
     activeSessions.clear();
     endCallback = null;
     clientGetter = null;
+    clientInfoGetter = null;
 }
 /**
  * Get a snapshot of active sessions (for testing/debugging).

package/dist/lib/server.js

@@ -11,7 +11,6 @@ import { consolidateMemories } from "./consolidation.js";
 import { assembleContext, cacheManifest, computeRelevanceScore, getCachedManifest, mapToContextEntity, recordContextFeedback, trackSessionAssembly, } from "./context-assembly.js";
 import { autoExpandGraph } from "./graph-expansion.js";
 import { runLifecycleMaintenance } from "./lifecycle-maintenance.js";
-import { generatePrompt, } from "./prompt-builder.js";
 const memorySessions = new Map();
 function initMemorySession(cardId, agentIdentifier, agentName) {
     memorySessions.set(cardId, {
@@ -2261,13 +2260,10 @@ async function handleToolCall(name, args, deps) {
         }
         // Prompt generation
         case "harmony_generate_prompt": {
-            // Get card - either by UUID or short ID
-            let cardData;
-            let columnData = null;
+            // Resolve card ID — either directly or via short ID
+            let cardId;
             if (args.cardId) {
-                const cardId = z.string().uuid().parse(args.cardId);
-                const cardResult = await client.getCard(cardId);
-                cardData = cardResult.card;
+                cardId = z.string().uuid().parse(args.cardId);
             }
             else if (args.shortId !== undefined) {
                 const shortId = z.number().int().positive().parse(args.shortId);
@@ -2276,32 +2272,12 @@ async function handleToolCall(name, args, deps) {
                     throw new Error("Project ID required when using shortId. Use harmony_set_project_context or provide projectId.");
                 }
                 const cardResult = await client.getCardByShortId(projectId, shortId);
-                cardData = cardResult.card;
+                cardId = cardResult.card.id;
             }
             else {
                 throw new Error("Either cardId or shortId must be provided");
             }
-            // Try to get column info from board
-            const projectIdForBoard = args.projectId ||
-                getActiveProjectId() ||
-                cardData.project_id;
-            if (projectIdForBoard) {
-                try {
-                    const board = await client.getBoard(projectIdForBoard, {
-                        summary: true,
-                    });
-                    const columnId = cardData
-                        .column_id;
-                    const column = board.columns.find((col) => col.id === columnId);
-                    if (column) {
-                        columnData = { name: column.name };
-                    }
-                }
-                catch {
-                    // Column info not available, continue without it
-                }
-            }
-            const variant = args.variant || "execute";
+            // Parse MCP-specific context options
             const contextOptions = {};
             if (args.includeSubtasks !== undefined) {
                 contextOptions.includeSubtasks =
@@ -2316,75 +2292,21 @@ async function handleToolCall(name, args, deps) {
                     args.includeDescription === true ||
                         args.includeDescription === "true";
             }
-            // Assemble context using the context assembly engine
-            let assembledContextStr;
-            let assemblyId;
-            let memories;
-            try {
-                const workspaceId = deps.getActiveWorkspaceId();
-                if (workspaceId && cardData.title) {
-                    const cardLabels = (cardData.labels || []).map((l) => l.name);
-                    const taskContext = [cardData.title, cardData.description || ""]
-                        .filter(Boolean)
-                        .join(" ");
-                    const assembled = await assembleContext({
-                        workspaceId,
-                        projectId: getActiveProjectId() || undefined,
-                        taskContext,
-                        cardLabels,
-                        cardId: cardData.id,
-                        client,
-                    });
-                    if (assembled.context) {
-                        assembledContextStr = assembled.context;
-                        assemblyId = assembled.manifest.assemblyId;
-                        cacheManifest(assembled.manifest);
-                    }
-                }
-            }
-            catch {
-                // Context assembly failed, try legacy fallback
-                try {
-                    const workspaceId = deps.getActiveWorkspaceId();
-                    if (workspaceId && cardData.title) {
-                        const memoryResult = await client.searchMemoryEntities(workspaceId, cardData.title, {
-                            project_id: getActiveProjectId() || undefined,
-                            limit: 5,
-                        });
-                        if (memoryResult.entities?.length > 0) {
-                            memories = memoryResult.entities.map((e) => {
-                                const entity = e;
-                                return {
-                                    id: entity.id,
-                                    type: entity.type,
-                                    title: entity.title,
-                                    content: entity.content,
-                                    confidence: entity.confidence,
-                                    tags: entity.tags || [],
-                                };
-                            });
-                        }
-                    }
-                }
-                catch {
-                    // Memory fetch also failed, continue without memories
-                }
-            }
-            const result = generatePrompt({
-                card: cardData,
-                column: columnData,
-                variant,
-                contextOptions,
+            // Delegate to the shared prompt generation pipeline
+            const result = await client.generateCardPrompt({
+                cardId,
+                workspaceId: deps.getActiveWorkspaceId() || "",
+                projectId: args.projectId || getActiveProjectId() || undefined,
+                variant: args.variant || "execute",
                 customConstraints: args.customConstraints,
-                memories,
-                assembledContext: assembledContextStr,
-                assemblyId,
+                contextOptions,
             });
+            // MCP-specific: cache the assembly manifest for the feedback loop
+            if (result.assemblyId) {
+                trackSessionAssembly(cardId, result.assemblyId);
+            }
             return {
                 success: true,
-                cardId: cardData.id,
-                shortId: cardData.short_id,
-                title: cardData.title,
                 ...result,
             };
         }
@@ -3267,11 +3189,14 @@ export class HarmonyMCPServer {
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
         console.error("Harmony MCP server running on stdio");
-        // Initialize auto-session tracking
+        // Initialize auto-session tracking with MCP client identity detection
         const configDeps = createConfigDeps();
         initAutoSession(async (client, cardId, status) => {
             await runEndSessionPipeline(client, configDeps, cardId, status);
-        }, () => getClient());
+        }, () => getClient(), () => {
+            const cv = this.server.getClientVersion();
+            return cv ? { name: cv.name, version: cv.version } : null;
+        });
         // Graceful shutdown: end all auto-sessions
         const handleShutdown = async () => {
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gethmy/mcp",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"