@gethmy/mcp 2.1.3 → 2.2.0

package/dist/lib/http.js

@@ -17,6 +17,7 @@ const app = new Hono();
 app.use("/*", cors({
     origin: [
         "https://gethmy.com",
+        "https://app.gethmy.com",
         "http://localhost:8080",
         "http://localhost:3000",
     ],

package/dist/lib/prompt-builder.js

@@ -301,6 +301,7 @@ export function generatePrompt(options) {
     roleFraming.focus.forEach((f) => {
         sections.push(`- ${f}`);
     });
+    sections.push(`- **Memory:** When you discover important domain knowledge, architectural decisions, or infrastructure details, store them via \`harmony_remember\`. Focus on durable knowledge that future agents would benefit from — not ephemeral task details (those are auto-extracted from your session).`);
     // Output suggestions
     sections.push(`\n## Suggested Outputs`);
     roleFraming.outputSuggestions.forEach((s) => {

package/dist/lib/remote.js

@@ -9,7 +9,7 @@
  *   Claude.ai → POST https://mcp.gethmy.com/mcp (Bearer: hmy_xxx)
  *
  * Env vars:
- *   HARMONY_API_URL - Harmony API base URL (default: https://gethmy.com/api)
+ *   HARMONY_API_URL - Harmony API base URL (default: https://app.gethmy.com/api)
  *   PORT            - Listen port (default: 3002)
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -22,7 +22,7 @@ import { registerHandlers } from "./server.js";
 // ---------------------------------------------------------------------------
 // Config from env
 // ---------------------------------------------------------------------------
-const HARMONY_API_URL = process.env.HARMONY_API_URL || "https://gethmy.com/api";
+const HARMONY_API_URL = process.env.HARMONY_API_URL || "https://app.gethmy.com/api";
 const PORT = parseInt(process.env.PORT || "3002", 10);
 async function validateApiKey(apiKey) {
     try {

package/dist/lib/server.js

@@ -12,6 +12,118 @@ import { assembleContext, cacheManifest, computeRelevanceScore, getCachedManifes
 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, {
+        cardId,
+        agentIdentifier,
+        agentName,
+        memoryReadCount: 0,
+        pendingActions: [],
+        allActions: [],
+        dirty: false,
+    });
+}
+function getMemorySession(cardId) {
+    return memorySessions.get(cardId);
+}
+function appendMemoryAction(cardId, action) {
+    const session = memorySessions.get(cardId);
+    if (!session)
+        return;
+    const truncated = action.length > 512 ? action.slice(0, 509) + "..." : action;
+    const entry = { action: truncated, ts: new Date().toISOString() };
+    session.pendingActions.push(entry);
+    session.dirty = true;
+}
+function incrementMemoryReads(cardId) {
+    const session = memorySessions.get(cardId);
+    if (!session)
+        return;
+    session.memoryReadCount++;
+    session.dirty = true;
+}
+/**
+ * Flush pending memory actions to the backend via updateAgentProgress.
+ * Fire-and-forget: errors are logged but never thrown.
+ */
+async function flushMemoryActions(client, cardId) {
+    const session = memorySessions.get(cardId);
+    if (!session || !session.dirty)
+        return;
+    try {
+        // Batch reads into a single summary line
+        if (session.memoryReadCount > 0) {
+            session.allActions.push({
+                action: `Recalled ${session.memoryReadCount} memor${session.memoryReadCount === 1 ? "y" : "ies"}`,
+                ts: new Date().toISOString(),
+            });
+            session.memoryReadCount = 0;
+        }
+        // Move pending writes to allActions
+        if (session.pendingActions.length > 0) {
+            session.allActions.push(...session.pendingActions);
+            session.pendingActions = [];
+        }
+        // Trim to max 10 (drop oldest)
+        if (session.allActions.length > 10) {
+            session.allActions = session.allActions.slice(-10);
+        }
+        await client.updateAgentProgress(cardId, {
+            agentIdentifier: session.agentIdentifier,
+            agentName: session.agentName,
+            recentActions: session.allActions,
+        });
+        session.dirty = false;
+    }
+    catch (err) {
+        // Fire-and-forget: log but don't propagate
+        console.error("[memory-session] flush failed:", err);
+    }
+}
+/**
+ * Merge memory actions into an existing recentActions array from a progress update.
+ * Returns the merged array (caller's actions first, then memory actions appended).
+ */
+function mergeMemoryActionsInto(cardId, callerActions) {
+    const session = memorySessions.get(cardId);
+    if (!session)
+        return callerActions;
+    // Flush reads into allActions
+    if (session.memoryReadCount > 0) {
+        session.allActions.push({
+            action: `Recalled ${session.memoryReadCount} memor${session.memoryReadCount === 1 ? "y" : "ies"}`,
+            ts: new Date().toISOString(),
+        });
+        session.memoryReadCount = 0;
+    }
+    // Move pending to allActions
+    if (session.pendingActions.length > 0) {
+        session.allActions.push(...session.pendingActions);
+        session.pendingActions = [];
+    }
+    // Merge: caller actions + memory actions, trim to 10
+    const merged = [...callerActions, ...session.allActions];
+    const trimmed = merged.length > 10 ? merged.slice(-10) : merged;
+    // Update allActions to the merged state
+    session.allActions = trimmed;
+    session.dirty = false;
+    return trimmed;
+}
+/**
+ * Get the first (and typically only) active memory session.
+ * Memory tools don't carry a cardId, so we find the active session.
+ */
+function getActiveMemorySession() {
+    // Return the first active session (there should be at most one)
+    for (const session of memorySessions.values()) {
+        return session;
+    }
+    return undefined;
+}
+function cleanupMemorySession(cardId) {
+    memorySessions.delete(cardId);
+}
 // Tool definitions
 const TOOLS = {
     // Card operations
@@ -1597,7 +1709,7 @@ async function handleToolCall(name, args, deps) {
     const unauthenticatedTools = ["harmony_signup", "harmony_onboard"];
     if (!unauthenticatedTools.includes(name) && !deps.isConfigured()) {
         throw new Error('Not configured. Run "npx @gethmy/mcp setup" to set your API key.\n' +
-            "You can generate an API key at https://gethmy.com → Settings → API Keys.\n" +
+            "You can generate an API key at https://app.gethmy.com → Settings → API Keys.\n" +
             'Or use "harmony_onboard" to create an account and configure automatically.');
     }
     const client = deps.isConfigured()
@@ -1944,7 +2056,9 @@ async function handleToolCall(name, args, deps) {
                 estimatedMinutesRemaining: args.estimatedMinutesRemaining,
             });
             // Mark as explicit so auto-session won't interfere
-            markExplicit(cardId);
+            markExplicit(cardId, { agentIdentifier, agentName });
+            // Initialize memory session tracking for action visibility
+            initMemorySession(cardId, agentIdentifier, agentName);
             // Prefetch relevant context (non-blocking, best-effort)
             let prefetchedMemoryIds = [];
             try {
@@ -2011,6 +2125,16 @@ async function handleToolCall(name, args, deps) {
             const progressPercent = args.progressPercent !== undefined
                 ? z.number().min(0).max(100).parse(args.progressPercent)
                 : undefined;
+            // Merge any pending memory actions into the progress update
+            const callerRecentActions = args.recentActions;
+            const memSession = getMemorySession(cardId);
+            let mergedRecentActions;
+            if (memSession?.dirty) {
+                mergedRecentActions = mergeMemoryActionsInto(cardId, callerRecentActions || []);
+            }
+            else if (callerRecentActions) {
+                mergedRecentActions = callerRecentActions;
+            }
             const result = await client.updateAgentProgress(cardId, {
                 agentIdentifier,
                 agentName,
@@ -2019,6 +2143,7 @@ async function handleToolCall(name, args, deps) {
                 currentTask: args.currentTask,
                 blockers: args.blockers,
                 estimatedMinutesRemaining: args.estimatedMinutesRemaining,
+                ...(mergedRecentActions && { recentActions: mergedRecentActions }),
             });
             // Mid-session learning extraction (fire-and-forget)
             let midSessionLearnings = 0;
@@ -2049,6 +2174,9 @@ async function handleToolCall(name, args, deps) {
             const endProgressPercent = args.progressPercent !== undefined
                 ? z.number().min(0).max(100).parse(args.progressPercent)
                 : undefined;
+            // Final flush of any pending memory actions before ending the session
+            await flushMemoryActions(client, cardId);
+            cleanupMemorySession(cardId);
             const result = await client.endAgentSession(cardId, {
                 status: sessionStatus,
                 progressPercent: endProgressPercent,
@@ -2270,6 +2398,8 @@ async function handleToolCall(name, args, deps) {
             }
             const entityType = args.type || "context";
             const entityTags = args.tags || [];
+            // Use session's agent identifier if available, otherwise null
+            const activeMemSession = getActiveMemorySession();
             const result = await client.createMemoryEntity({
                 workspace_id: workspaceId,
                 project_id: args.projectId || deps.getActiveProjectId() || undefined,
@@ -2283,7 +2413,7 @@ async function handleToolCall(name, args, deps) {
                     ? z.number().min(0).max(1).parse(args.confidence)
                     : undefined,
                 tags: entityTags.length > 0 ? entityTags : undefined,
-                agent_identifier: "claude-code",
+                agent_identifier: activeMemSession?.agentIdentifier || undefined,
             });
             // Fire-and-forget graph expansion: link new entity to semantically similar ones
             const newEntityIdForGraph = result.entity?.id;
@@ -2303,6 +2433,11 @@ async function handleToolCall(name, args, deps) {
                     // Don't block creation if contradiction detection fails
                 }
             }
+            // Track memory write action and flush (fire-and-forget)
+            if (activeMemSession) {
+                appendMemoryAction(activeMemSession.cardId, `Stored memory: ${title}`);
+                flushMemoryActions(client, activeMemSession.cardId).catch(() => { });
+            }
             return {
                 success: true,
                 ...result,
@@ -2373,6 +2508,11 @@ async function handleToolCall(name, args, deps) {
                     }
                 })).catch(() => { });
             }
+            // Track memory read (batched on flush)
+            const recallMemSession = getActiveMemorySession();
+            if (recallMemSession) {
+                incrementMemoryReads(recallMemSession.cardId);
+            }
             return markdown || "No memories found.";
         }
         case "harmony_update_memory": {
@@ -2393,11 +2533,35 @@ async function handleToolCall(name, args, deps) {
             if (args.metadata !== undefined)
                 updates.metadata = args.metadata;
             const result = await client.updateMemoryEntity(entityId, updates);
+            // Track memory write action and flush (fire-and-forget)
+            const updateMemSession = getActiveMemorySession();
+            if (updateMemSession) {
+                const updateTitle = updates.title || entityId.slice(0, 8);
+                appendMemoryAction(updateMemSession.cardId, `Updated memory: ${updateTitle}`);
+                flushMemoryActions(client, updateMemSession.cardId).catch(() => { });
+            }
             return { success: true, ...result };
         }
         case "harmony_forget": {
             const entityId = z.string().uuid().parse(args.entityId);
+            // Fetch title before deletion for action tracking
+            let forgetTitle = null;
+            const forgetMemSession = getActiveMemorySession();
+            if (forgetMemSession) {
+                try {
+                    const { entity } = await client.getMemoryEntity(entityId);
+                    forgetTitle = entity?.title || null;
+                }
+                catch {
+                    // Non-fatal: use truncated ID if fetch fails
+                }
+            }
             await client.deleteMemoryEntity(entityId);
+            // Track memory write action and flush (fire-and-forget)
+            if (forgetMemSession) {
+                appendMemoryAction(forgetMemSession.cardId, `Removed memory: ${forgetTitle || entityId.slice(0, 8)}`);
+                flushMemoryActions(client, forgetMemSession.cardId).catch(() => { });
+            }
             return { success: true };
         }
         case "harmony_relate": {
@@ -2423,6 +2587,12 @@ async function handleToolCall(name, args, deps) {
                     ? z.number().min(0).max(1).parse(args.confidence)
                     : undefined,
             });
+            // Track memory write action and flush (fire-and-forget)
+            const relateMemSession = getActiveMemorySession();
+            if (relateMemSession) {
+                appendMemoryAction(relateMemSession.cardId, `Linked memories: ${relationType}`);
+                flushMemoryActions(client, relateMemSession.cardId).catch(() => { });
+            }
             return { success: true, ...result };
         }
         case "harmony_memory_search": {
@@ -2438,6 +2608,11 @@ async function handleToolCall(name, args, deps) {
                 type: args.type,
                 limit: args.limit,
             });
+            // Track memory read (batched on flush)
+            const searchMemSession = getActiveMemorySession();
+            if (searchMemSession) {
+                incrementMemoryReads(searchMemSession.cardId);
+            }
             return markdown || "No memories found.";
         }
         // Vault index
@@ -2537,7 +2712,7 @@ async function handleToolCall(name, args, deps) {
                 tasks: args.tasks,
             });
             // Build URL for viewing the plan
-            const planUrl = `https://gethmy.com/plans/${result.plan.id}`;
+            const planUrl = `https://app.gethmy.com/plans/${result.plan.id}`;
             return {
                 success: true,
                 planId: result.plan.id,

package/dist/lib/skills.js

@@ -246,7 +246,7 @@ Once you have the plan ID, call \`harmony_get_plan\` to fetch the full plan with
 ## [Plan Title]
 **Status:** draft/active/archived | **Phase:** plan/execute/verify/done
 **Tasks:** N total (X pending, Y in_progress, Z completed)
-**URL:** https://gethmy.com/plans/{id}
+**URL:** https://app.gethmy.com/plans/{id}
 \\\`\\\`\\\`
 
 If plan is in execute phase and tasks already have linked cards, note which tasks have cards and which don't.
@@ -280,7 +280,7 @@ Only offer **(A) Single card**, **(C) Analyze only**, or **(D) Skip**.
 #### Option A — Single card
 1. Call \`harmony_create_card\` with:
    - \`title\`: Plan title
-   - \`description\`: Brief 2-3 sentence summary of the plan + \`\\n\\n[View plan](https://gethmy.com/plans/{planId})\`
+   - \`description\`: Brief 2-3 sentence summary of the plan + \`\\n\\n[View plan](https://app.gethmy.com/plans/{planId})\`
    - \`priority\`: based on plan task priorities (use highest)
 2. Call \`harmony_update_plan\` to set \`status: "active"\`, \`workflowPhase: "execute"\`
 
@@ -402,7 +402,7 @@ Call \`harmony_create_plan\` with:
 ### 2B.5 — User Approval
 
 Show the user:
-- Plan URL: \`https://gethmy.com/plans/{id}\`
+- Plan URL: \`https://app.gethmy.com/plans/{id}\`
 - Number of tasks created
 - Brief summary
 

package/dist/lib/tui/setup.js

@@ -11,7 +11,7 @@ import { getWriteSummary, writeFilesWithProgress } from "./writer.js";
 // Central skills directory for global installation
 const GLOBAL_SKILLS_DIR = join(homedir(), ".agents", "skills");
 // API base URL
-const API_URL = "https://gethmy.com/api";
+const API_URL = "https://app.gethmy.com/api";
 /**
  * Register MCP server using Claude CLI
  * Returns true if successful, false if CLI unavailable or failed
@@ -422,7 +422,7 @@ export async function runSetup(options = {}) {
     if (!validation.valid) {
         spinner.stop(colors.error("API key validation failed"));
         p.log.error(validation.error || "Could not connect to Harmony API");
-        p.log.info("Get an API key at: https://gethmy.com/user/keys");
+        p.log.info("Get an API key at: https://app.gethmy.com/user/keys");
         process.exit(1);
     }
     if (!userEmail) {
@@ -765,6 +765,6 @@ export async function runSetup(options = {}) {
     }
     console.log("");
     console.log(`  ${colors.dim("Add to new project: npx @gethmy/mcp setup")}`);
-    console.log(`  ${colors.dim("Need help? Visit https://gethmy.com/docs/mcp")}`);
+    console.log(`  ${colors.dim("Need help? Visit https://app.gethmy.com/docs/mcp")}`);
     console.log("");
 }

package/package.json

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

package/src/auto-session.ts

@@ -118,11 +118,18 @@ export async function trackActivity(
 
 /**
  * Mark a session as explicitly started (won't be auto-ended by card switching or inactivity).
+ * Optionally accepts the real agent identifier/name to store in the session.
  */
-export function markExplicit(cardId: string): void {
+export function markExplicit(
+  cardId: string,
+  options?: { agentIdentifier?: string; agentName?: string },
+): void {
   const existing = activeSessions.get(cardId);
   if (existing) {
     existing.isExplicit = true;
+    if (options?.agentIdentifier)
+      existing.agentIdentifier = options.agentIdentifier;
+    if (options?.agentName) existing.agentName = options.agentName;
   } else {
     // Track the explicit session even if we didn't auto-start it
     activeSessions.set(cardId, {
@@ -130,8 +137,8 @@ export function markExplicit(cardId: string): void {
       startedAt: Date.now(),
       lastActivityAt: Date.now(),
       isExplicit: true,
-      agentIdentifier: "explicit",
-      agentName: "Explicit Agent",
+      agentIdentifier: options?.agentIdentifier ?? "explicit",
+      agentName: options?.agentName ?? "Explicit Agent",
     });
   }
 }

package/src/cli.ts

@@ -113,7 +113,7 @@ program
     } else {
       console.log("Status: Not configured\n");
       console.log("Run: npx @gethmy/mcp setup");
-      console.log("Get an API key at: https://gethmy.com/user/keys");
+      console.log("Get an API key at: https://app.gethmy.com/user/keys");
     }
   });
 

package/src/config.ts

@@ -20,7 +20,7 @@ export interface LocalConfig {
   projectId: string | null;
 }
 
-const DEFAULT_API_URL = "https://gethmy.com/api";
+const DEFAULT_API_URL = "https://app.gethmy.com/api";
 const LOCAL_CONFIG_FILENAME = ".harmony-mcp.json";
 
 export function getConfigDir(): string {

package/src/http.ts

@@ -23,6 +23,7 @@ app.use(
   cors({
     origin: [
       "https://gethmy.com",
+      "https://app.gethmy.com",
       "http://localhost:8080",
       "http://localhost:3000",
     ],

package/src/prompt-builder.ts

@@ -438,6 +438,9 @@ export function generatePrompt(
   roleFraming.focus.forEach((f) => {
     sections.push(`- ${f}`);
   });
+  sections.push(
+    `- **Memory:** When you discover important domain knowledge, architectural decisions, or infrastructure details, store them via \`harmony_remember\`. Focus on durable knowledge that future agents would benefit from — not ephemeral task details (those are auto-extracted from your session).`,
+  );
 
   // Output suggestions
   sections.push(`\n## Suggested Outputs`);

package/src/remote.ts

@@ -10,7 +10,7 @@
  *   Claude.ai → POST https://mcp.gethmy.com/mcp (Bearer: hmy_xxx)
  *
  * Env vars:
- *   HARMONY_API_URL - Harmony API base URL (default: https://gethmy.com/api)
+ *   HARMONY_API_URL - Harmony API base URL (default: https://app.gethmy.com/api)
  *   PORT            - Listen port (default: 3002)
  */
 
@@ -25,7 +25,7 @@ import { registerHandlers, type ToolDeps } from "./server.js";
 // ---------------------------------------------------------------------------
 // Config from env
 // ---------------------------------------------------------------------------
-const HARMONY_API_URL = process.env.HARMONY_API_URL || "https://gethmy.com/api";
+const HARMONY_API_URL = process.env.HARMONY_API_URL || "https://app.gethmy.com/api";
 const PORT = parseInt(process.env.PORT || "3002", 10);
 
 // ---------------------------------------------------------------------------