harmony-mcp 1.14.0 → 1.14.2

package/README.md

@@ -5,7 +5,7 @@ Enables AI coding agents (Claude Code, OpenAI Codex, Cursor, Windsurf) to intera
 
 ## Features
 
-- **43+ MCP Tools** for full board control, knowledge graph, and workflow plans
+- **61+ MCP Tools** for full board control, knowledge graph, and workflow plans
 - **Knowledge Graph Memory** - persistent memory with entity types, tiers, scopes, and typed relations
 - **Active Learning** - auto-extracts lessons, solutions, and error patterns from completed work sessions
 - **Context Assembly** - token-budget-aware memory injection into AI prompts
@@ -13,6 +13,7 @@ Enables AI coding agents (Claude Code, OpenAI Codex, Cursor, Windsurf) to intera
 - **Card Linking** - create relationships between cards (blocks, relates_to, duplicates, is_part_of)
 - **Prompt Builder** - generate AI-ready prompts from cards with context
 - **Agent Session Tracking** - track work progress with timer badges
+- **Auto-Session Detection** - automatically starts/ends sessions when agents interact with cards
 - **Auto-Assignment** - automatically assign cards to you when starting agent sessions
 - **Memory Sync** - bidirectional sync between local markdown files and remote database
 - **Multi-Agent Support** - works with Claude Code, Codex, Cursor, Windsurf
@@ -89,7 +90,7 @@ If you prefer to configure manually (e.g., in Claude.ai's UI):
 1. Get an API key from [Harmony](https://gethmy.com/user/keys)
 2. In Claude.ai, add a remote MCP server with URL `https://mcp.gethmy.com/mcp`
 3. Set the Authorization header to `Bearer hmy_your_key_here`
-4. All 43+ Harmony tools become available in your conversation
+4. All 61+ Harmony tools become available in your conversation
 
 **Session management** is automatic - sessions have a 1-hour TTL and are created/renewed transparently.
 
@@ -167,6 +168,8 @@ When you start working on a card (e.g., `/hmy #42`):
 - `harmony_create_card` - Create a new card
 - `harmony_update_card` - Update card properties
 - `harmony_move_card` - Move card to different column (auto-ends agent session on move to done/review)
+- `harmony_archive_card` - Archive a card (soft-delete, can be restored)
+- `harmony_unarchive_card` - Restore an archived card back to the board
 - `harmony_delete_card` - Delete a card
 - `harmony_assign_card` - Assign to team member
 - `harmony_search_cards` - Search by title/description
@@ -209,7 +212,7 @@ When you start working on a card (e.g., `/hmy #42`):
 
 - `harmony_list_workspaces` - List workspaces
 - `harmony_list_projects` - List projects
-- `harmony_get_board` - Get board state (supports pagination via `limit`/`offset`, `summary` mode, `columnId` filter)
+- `harmony_get_board` - Get board state (supports pagination via `limit`/`offset`, `summary` mode, `columnId` filter, `includeArchived`)
 - `harmony_get_workspace_members` - Get team members
 - `harmony_set_workspace_context` - Set active workspace
 - `harmony_set_project_context` - Set active project
@@ -225,6 +228,20 @@ When you start working on a card (e.g., `/hmy #42`):
 - `harmony_update_agent_progress` - Update progress, status, blockers
 - `harmony_end_agent_session` - End session (completed/paused); triggers active learning extraction
 - `harmony_get_agent_session` - Get current session state
+- `harmony_get_agent_profile` - Get aggregate performance profile for an agent
+
+### Auto-Session Detection
+
+Sessions are automatically started when agents call card-mutating tools without an explicit `harmony_start_agent_session`. This ensures work is always tracked, even when agents don't explicitly manage sessions.
+
+**Trigger tools:** `harmony_generate_prompt`, `harmony_update_card`, `harmony_move_card`, `harmony_create_subtask`, `harmony_toggle_subtask`, `harmony_add_label_to_card`, `harmony_remove_label_from_card`
+
+**Behavior:**
+- Auto-starts a session when any trigger tool is called on a card without an active session
+- Auto-ends after 10 minutes of inactivity
+- Switching to a different card auto-ends the previous auto-session
+- Explicitly started sessions (via `harmony_start_agent_session`) are never auto-ended
+- Auto-ended sessions trigger the full active learning pipeline
 
 ### Prompt Generation
 
@@ -256,7 +273,7 @@ Store and retrieve persistent knowledge across sessions. Memories have types, ti
 - `harmony_memory_search` - Full-text search across the knowledge base
 - `harmony_relate` - Create a typed relationship between two memory entities
 
-**Entity Types:** `agent`, `task`, `decision`, `context`, `pattern`, `error`, `solution`, `preference`, `relationship`, `commitment`, `lesson`, `project`, `handoff`
+**Entity Types:** `agent`, `task`, `decision`, `context`, `pattern`, `error`, `solution`, `preference`, `relationship`, `commitment`, `lesson`, `project`, `handoff`, `procedure`
 
 **Memory Tiers:** `draft` (working notes) → `episode` (session summaries) → `reference` (durable knowledge)
 
@@ -274,6 +291,9 @@ Store and retrieve persistent knowledge across sessions. Memories have types, ti
 
 - `harmony_promote_memory` - Promote entity tier: `draft` → `episode` or `episode` → `reference`
 - `harmony_prune_draft` - Remove stale draft memories (dry-run mode by default)
+- `harmony_consolidate_memories` - Cluster similar draft/episode memories and merge into reference entities (dry-run by default)
+- `harmony_backfill_embeddings` - Generate vector embeddings for entities missing them
+- `harmony_backfill_relations` - Retroactively create semantic relations across existing entities
 
 ### Context Debugging
 
@@ -285,6 +305,7 @@ Store and retrieve persistent knowledge across sessions. Memories have types, ti
 
 Create and manage project plans with a phased workflow: **plan** → **execute** → **verify** → **done**.
 
+- `harmony_list_plans` - List plans in a project (filter by status or workflow phase)
 - `harmony_create_plan` - Create a new plan with embedded tasks
 - `harmony_get_plan` - Get plan by ID or card ID
 - `harmony_update_plan` - Update plan title, content, status, or phase
@@ -293,6 +314,15 @@ Create and manage project plans with a phased workflow: **plan** → **execute**
   - **execute → verify:** checks card completion status
   - **verify → done:** archives plan, creates memory entities
 
+### Onboarding & Account
+
+- `harmony_onboard` - Complete end-to-end onboarding: signup → workspace → project → API key
+- `harmony_signup` - Create a new user account
+- `harmony_create_workspace` - Create a new workspace
+- `harmony_create_project` - Create a new project with template columns (kanban, scrum, or simple)
+- `harmony_send_invitations` - Send workspace invitations to team members
+- `harmony_generate_api_key` - Generate an API key for the authenticated user
+
 ## Direct API Access
 
 You can also call the Harmony API directly from any HTTP client:

package/dist/cli.js

@@ -25315,7 +25315,8 @@ async function findSimilarEntities(client2, title, content, workspaceId, options
   try {
     const { entities } = await client2.searchMemoryEntities(workspaceId, query, {
       project_id: options?.projectId,
-      limit: options?.limit ?? 20
+      limit: options?.limit ?? 20,
+      type: options?.type
     });
     const minScore = options?.minRrfScore ?? 0;
     const excludeSet = new Set(options?.excludeIds || []);
@@ -25330,6 +25331,57 @@ async function findSimilarEntities(client2, title, content, workspaceId, options
     return [];
   }
 }
+var CAUSAL_LOOKUP = [
+  {
+    sourceType: "error",
+    targetType: "solution",
+    relation: "resolved_by",
+    direction: "forward"
+  },
+  {
+    sourceType: "solution",
+    targetType: "error",
+    relation: "resolved_by",
+    direction: "reverse"
+  },
+  {
+    sourceType: "lesson",
+    targetType: "error",
+    relation: "learned_from",
+    direction: "forward"
+  }
+];
+async function linkCrossTypeNeighbors(client2, entityId, entityType, title, content, workspaceId, projectId) {
+  const rules = CAUSAL_LOOKUP.filter((r) => r.sourceType === entityType);
+  if (rules.length === 0)
+    return { relationsCreated: 0 };
+  let relationsCreated = 0;
+  for (const rule of rules) {
+    try {
+      const matches = await findSimilarEntities(client2, title, content, workspaceId, {
+        projectId,
+        limit: 10,
+        minRrfScore: 0.04,
+        excludeIds: [entityId],
+        type: rule.targetType
+      });
+      for (const match of matches.slice(0, 3)) {
+        const sourceId = rule.direction === "forward" ? entityId : match.id;
+        const targetId = rule.direction === "forward" ? match.id : entityId;
+        try {
+          await client2.createMemoryRelation({
+            source_id: sourceId,
+            target_id: targetId,
+            relation_type: rule.relation,
+            confidence: 0.65
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    } catch {}
+  }
+  return { relationsCreated };
+}
 
 // src/active-learning.ts
 var CONTRADICTION_TYPES = new Set([
@@ -25602,6 +25654,31 @@ Agent: ${session.agentName} | ${new Date().toISOString().split("T")[0]}`;
     }
   };
 }
+var SESSION_CAUSAL_RULES = [
+  { sourceType: "error", targetType: "solution", relation: "resolved_by", confidence: 0.8 },
+  { sourceType: "lesson", targetType: "error", relation: "learned_from", confidence: 0.75 }
+];
+async function linkSessionEntities(client2, createdPairs, _workspaceId, _projectId) {
+  let relationsCreated = 0;
+  for (const rule of SESSION_CAUSAL_RULES) {
+    const sources = createdPairs.filter((p) => p.learning.type === rule.sourceType);
+    const targets = createdPairs.filter((p) => p.learning.type === rule.targetType);
+    for (const source of sources) {
+      for (const target of targets) {
+        try {
+          await client2.createMemoryRelation({
+            source_id: source.id,
+            target_id: target.id,
+            relation_type: rule.relation,
+            confidence: rule.confidence
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    }
+  }
+  return { relationsCreated };
+}
 async function extractLearnings(client2, session) {
   const workspaceId = getActiveWorkspaceId();
   if (!workspaceId) {
@@ -25743,10 +25820,17 @@ Agent: ${session.agentName}`,
   for (const { id, learning } of createdPairs) {
     autoExpandGraph(client2, id, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => {});
     detectContradictions(client2, id, learning.type, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => {});
+    linkCrossTypeNeighbors(client2, id, learning.type, learning.title, learning.content, workspaceId, projectId).catch(() => {});
+  }
+  if (createdPairs.length >= 2) {
+    linkSessionEntities(client2, createdPairs, workspaceId, projectId).catch(() => {});
   }
   if (entityIds.length > 0) {
     detectAndCreatePatterns(client2, entityIds, session, workspaceId, projectId).catch(() => {});
   }
+  if (createdPairs.length > 0) {
+    detectCausalPatterns(client2, createdPairs, session, workspaceId, projectId).catch(() => {});
+  }
   clearMidSessionTracking(session.cardId);
   return { count: entityIds.length, entityIds };
 }
@@ -25837,6 +25921,122 @@ ${memberTitles.map((t) => `- ${t}`).join(`
   }
   return patternEntityIds;
 }
+var CAUSAL_PATTERN_THRESHOLD = 3;
+async function detectCausalPatterns(client2, createdPairs, session, workspaceId, projectId) {
+  const patternIds = [];
+  const errors3 = createdPairs.filter((p) => p.learning.type === "error");
+  const solutions = createdPairs.filter((p) => p.learning.type === "solution");
+  if (errors3.length === 0 || solutions.length === 0)
+    return patternIds;
+  for (const errorPair of errors3) {
+    try {
+      const similarErrors = await findSimilarEntities(client2, errorPair.learning.title, errorPair.learning.content, workspaceId, {
+        projectId,
+        limit: 20,
+        minRrfScore: 0.03,
+        excludeIds: createdPairs.map((p) => p.id),
+        type: "error"
+      });
+      const resolvedErrors = [];
+      for (const similar of similarErrors.slice(0, 10)) {
+        try {
+          const { outgoing } = await client2.getRelatedEntities(similar.id);
+          const resolvedByRel = outgoing.find((r) => r.relation_type === "resolved_by");
+          if (resolvedByRel) {
+            resolvedErrors.push({
+              errorId: similar.id,
+              errorTitle: similar.title,
+              solutionTitle: resolvedByRel.target_title || "unknown"
+            });
+          }
+        } catch {}
+      }
+      if (resolvedErrors.length + 1 < CAUSAL_PATTERN_THRESHOLD)
+        continue;
+      const { entities: existingPatterns } = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        type: "pattern",
+        limit: 10
+      });
+      const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_chain_type === "error_resolved_by_solution");
+      if (matchingPattern) {
+        await client2.updateMemoryEntity(matchingPattern.id, {
+          content: [
+            `Recurring error→solution chain detected (${resolvedErrors.length + 1} instances).`,
+            "",
+            "## Error→Solution Pairs",
+            `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
+            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`),
+            "",
+            `Last updated: ${new Date().toISOString()}`
+          ].join(`
+`),
+          metadata: {
+            pattern_chain_type: "error_resolved_by_solution",
+            pattern_count: resolvedErrors.length + 1,
+            last_updated: new Date().toISOString()
+          }
+        });
+        for (const pair of [errorPair, solutions[0]]) {
+          try {
+            await client2.createMemoryRelation({
+              source_id: pair.id,
+              target_id: matchingPattern.id,
+              relation_type: "part_of",
+              confidence: 0.75
+            });
+          } catch {}
+        }
+      } else {
+        const result = await client2.createMemoryEntity({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          type: "pattern",
+          scope: "project",
+          memory_tier: "reference",
+          title: `Pattern: recurring error→solution chain (${resolvedErrors.length + 1} instances)`,
+          content: [
+            `Recurring error→solution chain detected across ${resolvedErrors.length + 1} sessions.`,
+            "",
+            "## Error→Solution Pairs",
+            `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
+            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`)
+          ].join(`
+`),
+          confidence: 0.8,
+          tags: ["auto-extracted", "pattern", "causal-chain"],
+          metadata: {
+            source: "causal_pattern_detection",
+            pattern_chain_type: "error_resolved_by_solution",
+            pattern_count: resolvedErrors.length + 1
+          },
+          agent_identifier: session.agentIdentifier
+        });
+        const created = result.entity;
+        if (created?.id) {
+          patternIds.push(created.id);
+          const memberIds = [
+            errorPair.id,
+            solutions[0].id,
+            ...resolvedErrors.slice(0, 4).map((r) => r.errorId)
+          ];
+          for (const memberId of memberIds) {
+            try {
+              await client2.createMemoryRelation({
+                source_id: memberId,
+                target_id: created.id,
+                relation_type: "part_of",
+                confidence: 0.75
+              });
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+  return patternIds;
+}
 async function detectContradictions(client2, entityId, entityType, title, content, tags, workspaceId, projectId) {
   if (!CONTRADICTION_TYPES.has(entityType))
     return [];
@@ -25883,125 +26083,6 @@ async function detectContradictions(client2, entityId, entityType, title, conten
   }
 }
 
-// src/auto-session.ts
-var AUTO_START_TRIGGERS = new Set([
-  "harmony_generate_prompt",
-  "harmony_update_card",
-  "harmony_move_card",
-  "harmony_create_subtask",
-  "harmony_toggle_subtask",
-  "harmony_add_label_to_card",
-  "harmony_remove_label_from_card"
-]);
-var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
-var CHECK_INTERVAL_MS = 60 * 1000;
-var activeSessions = new Map;
-var inactivityTimer = null;
-var endCallback = null;
-var clientGetter = null;
-function initAutoSession(callback, getClient) {
-  endCallback = callback;
-  clientGetter = getClient;
-  if (inactivityTimer)
-    clearInterval(inactivityTimer);
-  inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
-}
-async function trackActivity(cardId, options) {
-  const now = Date.now();
-  const existing = activeSessions.get(cardId);
-  if (existing) {
-    existing.lastActivityAt = now;
-    return;
-  }
-  if (!options?.autoStart)
-    return;
-  const client2 = options?.client ?? clientGetter?.();
-  if (!client2)
-    return;
-  const toEnd = [];
-  for (const [otherCardId, session] of activeSessions) {
-    if (otherCardId !== cardId && !session.isExplicit) {
-      toEnd.push(otherCardId);
-    }
-  }
-  for (const otherCardId of toEnd) {
-    await autoEndSession(client2, otherCardId, "completed");
-  }
-  try {
-    await client2.startAgentSession(cardId, {
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
-      status: "working"
-    });
-  } catch {}
-  activeSessions.set(cardId, {
-    cardId,
-    startedAt: now,
-    lastActivityAt: now,
-    isExplicit: false,
-    agentIdentifier: "auto",
-    agentName: "Auto-detected Agent"
-  });
-}
-function markExplicit(cardId) {
-  const existing = activeSessions.get(cardId);
-  if (existing) {
-    existing.isExplicit = true;
-  } else {
-    activeSessions.set(cardId, {
-      cardId,
-      startedAt: Date.now(),
-      lastActivityAt: Date.now(),
-      isExplicit: true,
-      agentIdentifier: "explicit",
-      agentName: "Explicit Agent"
-    });
-  }
-}
-function untrack(cardId) {
-  activeSessions.delete(cardId);
-}
-async function shutdownAllSessions() {
-  const client2 = clientGetter?.();
-  if (!client2)
-    return;
-  const cardIds = [...activeSessions.keys()];
-  const promises = cardIds.map((cardId) => autoEndSession(client2, cardId, "paused"));
-  await Promise.allSettled(promises);
-}
-function destroyAutoSession() {
-  if (inactivityTimer) {
-    clearInterval(inactivityTimer);
-    inactivityTimer = null;
-  }
-  activeSessions.clear();
-  endCallback = null;
-  clientGetter = null;
-}
-function checkInactivity() {
-  const now = Date.now();
-  const client2 = clientGetter?.();
-  if (!client2)
-    return;
-  const entries = [...activeSessions.entries()];
-  for (const [cardId, session] of entries) {
-    if (session.isExplicit)
-      continue;
-    if (now - session.lastActivityAt > INACTIVITY_TIMEOUT_MS) {
-      autoEndSession(client2, cardId, "completed").catch(() => {});
-    }
-  }
-}
-async function autoEndSession(client2, cardId, status) {
-  activeSessions.delete(cardId);
-  try {
-    await client2.endAgentSession(cardId, { status });
-  } catch {}
-  try {
-    await endCallback?.(client2, cardId, status);
-  } catch {}
-}
-
 // src/api-client.ts
 var RETRY_CONFIG = {
   maxRetries: 3,
@@ -26302,6 +26383,22 @@ class HarmonyApiClient {
     const query = params.toString() ? `?${params.toString()}` : "";
     return this.request("GET", `/cards/${cardId}/agent-context${query}`);
   }
+  async getAgentProfile(workspaceId, agentIdentifier) {
+    const params = new URLSearchParams({
+      workspace_id: workspaceId,
+      agent_identifier: agentIdentifier
+    });
+    return this.request("GET", `/agent-profiles?${params.toString()}`);
+  }
+  async listAgentProfiles(workspaceId) {
+    const params = new URLSearchParams({ workspace_id: workspaceId });
+    return this.request("GET", `/agent-profiles?${params.toString()}`);
+  }
+  async refreshAgentProfiles(workspaceId) {
+    return this.request("POST", "/agent-profiles/refresh", {
+      workspace_id: workspaceId
+    });
+  }
   async createMemoryEntity(data) {
     return this.request("POST", "/memory/entities", data);
   }
@@ -26505,6 +26602,125 @@ function resetClient() {
   client2 = null;
 }
 
+// src/auto-session.ts
+var AUTO_START_TRIGGERS = new Set([
+  "harmony_generate_prompt",
+  "harmony_update_card",
+  "harmony_move_card",
+  "harmony_create_subtask",
+  "harmony_toggle_subtask",
+  "harmony_add_label_to_card",
+  "harmony_remove_label_from_card"
+]);
+var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
+var CHECK_INTERVAL_MS = 60 * 1000;
+var activeSessions = new Map;
+var inactivityTimer = null;
+var endCallback = null;
+var clientGetter = null;
+function initAutoSession(callback, getClient2) {
+  endCallback = callback;
+  clientGetter = getClient2;
+  if (inactivityTimer)
+    clearInterval(inactivityTimer);
+  inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
+}
+async function trackActivity(cardId, options) {
+  const now = Date.now();
+  const existing = activeSessions.get(cardId);
+  if (existing) {
+    existing.lastActivityAt = now;
+    return;
+  }
+  if (!options?.autoStart)
+    return;
+  const client3 = options?.client ?? clientGetter?.();
+  if (!client3)
+    return;
+  const toEnd = [];
+  for (const [otherCardId, session] of activeSessions) {
+    if (otherCardId !== cardId && !session.isExplicit) {
+      toEnd.push(otherCardId);
+    }
+  }
+  for (const otherCardId of toEnd) {
+    await autoEndSession(client3, otherCardId, "completed");
+  }
+  try {
+    await client3.startAgentSession(cardId, {
+      agentIdentifier: "auto",
+      agentName: "Auto-detected Agent",
+      status: "working"
+    });
+  } catch {}
+  activeSessions.set(cardId, {
+    cardId,
+    startedAt: now,
+    lastActivityAt: now,
+    isExplicit: false,
+    agentIdentifier: "auto",
+    agentName: "Auto-detected Agent"
+  });
+}
+function markExplicit(cardId) {
+  const existing = activeSessions.get(cardId);
+  if (existing) {
+    existing.isExplicit = true;
+  } else {
+    activeSessions.set(cardId, {
+      cardId,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now(),
+      isExplicit: true,
+      agentIdentifier: "explicit",
+      agentName: "Explicit Agent"
+    });
+  }
+}
+function untrack(cardId) {
+  activeSessions.delete(cardId);
+}
+async function shutdownAllSessions() {
+  const client3 = clientGetter?.();
+  if (!client3)
+    return;
+  const cardIds = [...activeSessions.keys()];
+  const promises = cardIds.map((cardId) => autoEndSession(client3, cardId, "paused"));
+  await Promise.allSettled(promises);
+}
+function destroyAutoSession() {
+  if (inactivityTimer) {
+    clearInterval(inactivityTimer);
+    inactivityTimer = null;
+  }
+  activeSessions.clear();
+  endCallback = null;
+  clientGetter = null;
+}
+function checkInactivity() {
+  const now = Date.now();
+  const client3 = clientGetter?.();
+  if (!client3)
+    return;
+  const entries = [...activeSessions.entries()];
+  for (const [cardId, session] of entries) {
+    if (session.isExplicit)
+      continue;
+    if (now - session.lastActivityAt > INACTIVITY_TIMEOUT_MS) {
+      autoEndSession(client3, cardId, "completed").catch(() => {});
+    }
+  }
+}
+async function autoEndSession(client3, cardId, status) {
+  activeSessions.delete(cardId);
+  try {
+    await client3.endAgentSession(cardId, { status });
+  } catch {}
+  try {
+    await endCallback?.(client3, cardId, status);
+  } catch {}
+}
+
 // src/consolidation.ts
 async function consolidateMemories(client3, workspaceId, projectId, options) {
   const dryRun = options?.dryRun !== false;
@@ -28166,6 +28382,22 @@ var TOOLS = {
       required: ["cardId"]
     }
   },
+  harmony_get_agent_profile: {
+    description: "Get aggregate performance profile for an agent. Shows total sessions, completion rate, average duration, and more. Defaults to the current agent if no identifier provided.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentIdentifier: {
+          type: "string",
+          description: "Agent identifier (e.g., 'claude-code'). Defaults to current agent."
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        }
+      }
+    }
+  },
   harmony_generate_prompt: {
     description: "Generate an AI-ready prompt from a card. Automatically infers role and focus based on labels (bug, feature, design, etc.). Use this to create context-rich prompts for working on cards.",
     inputSchema: {
@@ -29023,6 +29255,62 @@ async function runEndSessionPipeline(client3, deps, cardId, sessionStatus, endPr
     const learningResult = await extractLearnings(client3, sessionContext);
     learningsExtracted = learningResult.count;
   } catch {}
+  try {
+    const workspaceId = deps.getActiveWorkspaceId();
+    const agentId = sessionData?.agent_identifier || "unknown";
+    if (workspaceId && agentId !== "unknown") {
+      (async () => {
+        try {
+          await client3.refreshAgentProfiles(workspaceId);
+          const { profile } = await client3.getAgentProfile(workspaceId, agentId);
+          if (profile) {
+            const p = profile;
+            const title = `Agent Profile: ${agentId}`;
+            const content = [
+              `## ${agentId} Performance Profile`,
+              "",
+              `- **Total sessions:** ${p.total_sessions}`,
+              `- **Completed:** ${p.completed_sessions} (${p.completion_rate_pct}%)`,
+              `- **Paused:** ${p.paused_sessions}`,
+              `- **Blocked:** ${p.blocked_sessions}`,
+              `- **Avg duration:** ${Math.round(Number(p.avg_active_duration_ms || 0) / 1000)}s`,
+              `- **Avg progress:** ${p.avg_completion_progress}%`,
+              `- **First session:** ${p.first_session_at}`,
+              `- **Last session:** ${p.last_session_at}`
+            ].join(`
+`);
+            const existing = await client3.listMemoryEntities({
+              workspace_id: workspaceId,
+              type: "agent",
+              limit: 50
+            });
+            const entities = existing.entities || [];
+            const match = entities.find((e) => e.title === title || e.agent_identifier === agentId);
+            if (match) {
+              await client3.updateMemoryEntity(match.id, {
+                content,
+                confidence: 1,
+                metadata: p
+              });
+            } else {
+              await client3.createMemoryEntity({
+                workspace_id: workspaceId,
+                type: "agent",
+                scope: "workspace",
+                memory_tier: "reference",
+                title,
+                content,
+                confidence: 1,
+                tags: ["agent-profile", agentId],
+                agent_identifier: agentId,
+                metadata: p
+              });
+            }
+          }
+        } catch {}
+      })();
+    }
+  } catch {}
   try {
     const feedbackResult = await recordContextFeedback(client3, cardId, sessionStatus, endProgressPercent, (sessionData?.blockers?.length ?? 0) > 0);
     feedbackAdjusted = feedbackResult.adjusted;
@@ -29517,18 +29805,18 @@ async function handleToolCall(name, args, deps) {
       });
       untrack(cardId);
       let movedTo = null;
-      let learningsExtracted = 0;
-      let cardTitle = "";
-      let cardLabels = [];
-      let cardDescription = "";
-      let cardSubtasks = [];
+      const _learningsExtracted = 0;
+      let _cardTitle = "";
+      let _cardLabels = [];
+      let _cardDescription = "";
+      let _cardSubtasks = [];
       try {
         const { card } = await client3.getCard(cardId);
         const typedCard = card;
-        cardTitle = typedCard.title || "";
-        cardLabels = (typedCard.labels || []).map((l) => l.name);
-        cardDescription = typedCard.description || "";
-        cardSubtasks = (typedCard.subtasks || []).map((s) => ({
+        _cardTitle = typedCard.title || "";
+        _cardLabels = (typedCard.labels || []).map((l) => l.name);
+        _cardDescription = typedCard.description || "";
+        _cardSubtasks = (typedCard.subtasks || []).map((s) => ({
           title: s.title,
           done: s.done
         }));
@@ -29571,6 +29859,18 @@ async function handleToolCall(name, args, deps) {
       });
       return { success: true, ...result };
     }
+    case "harmony_get_agent_profile": {
+      const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
+      if (!workspaceId) {
+        return {
+          success: false,
+          error: "No workspace context. Provide workspaceId or set context."
+        };
+      }
+      const agentIdentifier = args.agentIdentifier || "claude-code";
+      const result = await client3.getAgentProfile(workspaceId, agentIdentifier);
+      return { success: true, ...result };
+    }
     case "harmony_generate_prompt": {
       let cardData;
       let columnData = null;

package/dist/index.js

@@ -23075,7 +23075,8 @@ async function findSimilarEntities(client2, title, content, workspaceId, options
   try {
     const { entities } = await client2.searchMemoryEntities(workspaceId, query, {
       project_id: options?.projectId,
-      limit: options?.limit ?? 20
+      limit: options?.limit ?? 20,
+      type: options?.type
     });
     const minScore = options?.minRrfScore ?? 0;
     const excludeSet = new Set(options?.excludeIds || []);
@@ -23090,6 +23091,57 @@ async function findSimilarEntities(client2, title, content, workspaceId, options
     return [];
   }
 }
+var CAUSAL_LOOKUP = [
+  {
+    sourceType: "error",
+    targetType: "solution",
+    relation: "resolved_by",
+    direction: "forward"
+  },
+  {
+    sourceType: "solution",
+    targetType: "error",
+    relation: "resolved_by",
+    direction: "reverse"
+  },
+  {
+    sourceType: "lesson",
+    targetType: "error",
+    relation: "learned_from",
+    direction: "forward"
+  }
+];
+async function linkCrossTypeNeighbors(client2, entityId, entityType, title, content, workspaceId, projectId) {
+  const rules = CAUSAL_LOOKUP.filter((r) => r.sourceType === entityType);
+  if (rules.length === 0)
+    return { relationsCreated: 0 };
+  let relationsCreated = 0;
+  for (const rule of rules) {
+    try {
+      const matches = await findSimilarEntities(client2, title, content, workspaceId, {
+        projectId,
+        limit: 10,
+        minRrfScore: 0.04,
+        excludeIds: [entityId],
+        type: rule.targetType
+      });
+      for (const match of matches.slice(0, 3)) {
+        const sourceId = rule.direction === "forward" ? entityId : match.id;
+        const targetId = rule.direction === "forward" ? match.id : entityId;
+        try {
+          await client2.createMemoryRelation({
+            source_id: sourceId,
+            target_id: targetId,
+            relation_type: rule.relation,
+            confidence: 0.65
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    } catch {}
+  }
+  return { relationsCreated };
+}
 
 // src/active-learning.ts
 var CONTRADICTION_TYPES = new Set([
@@ -23362,6 +23414,31 @@ Agent: ${session.agentName} | ${new Date().toISOString().split("T")[0]}`;
     }
   };
 }
+var SESSION_CAUSAL_RULES = [
+  { sourceType: "error", targetType: "solution", relation: "resolved_by", confidence: 0.8 },
+  { sourceType: "lesson", targetType: "error", relation: "learned_from", confidence: 0.75 }
+];
+async function linkSessionEntities(client2, createdPairs, _workspaceId, _projectId) {
+  let relationsCreated = 0;
+  for (const rule of SESSION_CAUSAL_RULES) {
+    const sources = createdPairs.filter((p) => p.learning.type === rule.sourceType);
+    const targets = createdPairs.filter((p) => p.learning.type === rule.targetType);
+    for (const source of sources) {
+      for (const target of targets) {
+        try {
+          await client2.createMemoryRelation({
+            source_id: source.id,
+            target_id: target.id,
+            relation_type: rule.relation,
+            confidence: rule.confidence
+          });
+          relationsCreated++;
+        } catch {}
+      }
+    }
+  }
+  return { relationsCreated };
+}
 async function extractLearnings(client2, session) {
   const workspaceId = getActiveWorkspaceId();
   if (!workspaceId) {
@@ -23503,10 +23580,17 @@ Agent: ${session.agentName}`,
   for (const { id, learning } of createdPairs) {
     autoExpandGraph(client2, id, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => {});
     detectContradictions(client2, id, learning.type, learning.title, learning.content, learning.tags, workspaceId, projectId).catch(() => {});
+    linkCrossTypeNeighbors(client2, id, learning.type, learning.title, learning.content, workspaceId, projectId).catch(() => {});
+  }
+  if (createdPairs.length >= 2) {
+    linkSessionEntities(client2, createdPairs, workspaceId, projectId).catch(() => {});
   }
   if (entityIds.length > 0) {
     detectAndCreatePatterns(client2, entityIds, session, workspaceId, projectId).catch(() => {});
   }
+  if (createdPairs.length > 0) {
+    detectCausalPatterns(client2, createdPairs, session, workspaceId, projectId).catch(() => {});
+  }
   clearMidSessionTracking(session.cardId);
   return { count: entityIds.length, entityIds };
 }
@@ -23597,6 +23681,122 @@ ${memberTitles.map((t) => `- ${t}`).join(`
   }
   return patternEntityIds;
 }
+var CAUSAL_PATTERN_THRESHOLD = 3;
+async function detectCausalPatterns(client2, createdPairs, session, workspaceId, projectId) {
+  const patternIds = [];
+  const errors3 = createdPairs.filter((p) => p.learning.type === "error");
+  const solutions = createdPairs.filter((p) => p.learning.type === "solution");
+  if (errors3.length === 0 || solutions.length === 0)
+    return patternIds;
+  for (const errorPair of errors3) {
+    try {
+      const similarErrors = await findSimilarEntities(client2, errorPair.learning.title, errorPair.learning.content, workspaceId, {
+        projectId,
+        limit: 20,
+        minRrfScore: 0.03,
+        excludeIds: createdPairs.map((p) => p.id),
+        type: "error"
+      });
+      const resolvedErrors = [];
+      for (const similar of similarErrors.slice(0, 10)) {
+        try {
+          const { outgoing } = await client2.getRelatedEntities(similar.id);
+          const resolvedByRel = outgoing.find((r) => r.relation_type === "resolved_by");
+          if (resolvedByRel) {
+            resolvedErrors.push({
+              errorId: similar.id,
+              errorTitle: similar.title,
+              solutionTitle: resolvedByRel.target_title || "unknown"
+            });
+          }
+        } catch {}
+      }
+      if (resolvedErrors.length + 1 < CAUSAL_PATTERN_THRESHOLD)
+        continue;
+      const { entities: existingPatterns } = await client2.listMemoryEntities({
+        workspace_id: workspaceId,
+        project_id: projectId,
+        type: "pattern",
+        limit: 10
+      });
+      const matchingPattern = existingPatterns.find((p) => p.metadata?.pattern_chain_type === "error_resolved_by_solution");
+      if (matchingPattern) {
+        await client2.updateMemoryEntity(matchingPattern.id, {
+          content: [
+            `Recurring error→solution chain detected (${resolvedErrors.length + 1} instances).`,
+            "",
+            "## Error→Solution Pairs",
+            `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
+            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`),
+            "",
+            `Last updated: ${new Date().toISOString()}`
+          ].join(`
+`),
+          metadata: {
+            pattern_chain_type: "error_resolved_by_solution",
+            pattern_count: resolvedErrors.length + 1,
+            last_updated: new Date().toISOString()
+          }
+        });
+        for (const pair of [errorPair, solutions[0]]) {
+          try {
+            await client2.createMemoryRelation({
+              source_id: pair.id,
+              target_id: matchingPattern.id,
+              relation_type: "part_of",
+              confidence: 0.75
+            });
+          } catch {}
+        }
+      } else {
+        const result = await client2.createMemoryEntity({
+          workspace_id: workspaceId,
+          project_id: projectId,
+          type: "pattern",
+          scope: "project",
+          memory_tier: "reference",
+          title: `Pattern: recurring error→solution chain (${resolvedErrors.length + 1} instances)`,
+          content: [
+            `Recurring error→solution chain detected across ${resolvedErrors.length + 1} sessions.`,
+            "",
+            "## Error→Solution Pairs",
+            `- ${errorPair.learning.title} → ${solutions[0].learning.title}`,
+            ...resolvedErrors.slice(0, 5).map((r) => `- ${r.errorTitle} → ${r.solutionTitle}`)
+          ].join(`
+`),
+          confidence: 0.8,
+          tags: ["auto-extracted", "pattern", "causal-chain"],
+          metadata: {
+            source: "causal_pattern_detection",
+            pattern_chain_type: "error_resolved_by_solution",
+            pattern_count: resolvedErrors.length + 1
+          },
+          agent_identifier: session.agentIdentifier
+        });
+        const created = result.entity;
+        if (created?.id) {
+          patternIds.push(created.id);
+          const memberIds = [
+            errorPair.id,
+            solutions[0].id,
+            ...resolvedErrors.slice(0, 4).map((r) => r.errorId)
+          ];
+          for (const memberId of memberIds) {
+            try {
+              await client2.createMemoryRelation({
+                source_id: memberId,
+                target_id: created.id,
+                relation_type: "part_of",
+                confidence: 0.75
+              });
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+  return patternIds;
+}
 async function detectContradictions(client2, entityId, entityType, title, content, tags, workspaceId, projectId) {
   if (!CONTRADICTION_TYPES.has(entityType))
     return [];
@@ -23643,125 +23843,6 @@ async function detectContradictions(client2, entityId, entityType, title, conten
   }
 }
 
-// src/auto-session.ts
-var AUTO_START_TRIGGERS = new Set([
-  "harmony_generate_prompt",
-  "harmony_update_card",
-  "harmony_move_card",
-  "harmony_create_subtask",
-  "harmony_toggle_subtask",
-  "harmony_add_label_to_card",
-  "harmony_remove_label_from_card"
-]);
-var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
-var CHECK_INTERVAL_MS = 60 * 1000;
-var activeSessions = new Map;
-var inactivityTimer = null;
-var endCallback = null;
-var clientGetter = null;
-function initAutoSession(callback, getClient) {
-  endCallback = callback;
-  clientGetter = getClient;
-  if (inactivityTimer)
-    clearInterval(inactivityTimer);
-  inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
-}
-async function trackActivity(cardId, options) {
-  const now = Date.now();
-  const existing = activeSessions.get(cardId);
-  if (existing) {
-    existing.lastActivityAt = now;
-    return;
-  }
-  if (!options?.autoStart)
-    return;
-  const client2 = options?.client ?? clientGetter?.();
-  if (!client2)
-    return;
-  const toEnd = [];
-  for (const [otherCardId, session] of activeSessions) {
-    if (otherCardId !== cardId && !session.isExplicit) {
-      toEnd.push(otherCardId);
-    }
-  }
-  for (const otherCardId of toEnd) {
-    await autoEndSession(client2, otherCardId, "completed");
-  }
-  try {
-    await client2.startAgentSession(cardId, {
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
-      status: "working"
-    });
-  } catch {}
-  activeSessions.set(cardId, {
-    cardId,
-    startedAt: now,
-    lastActivityAt: now,
-    isExplicit: false,
-    agentIdentifier: "auto",
-    agentName: "Auto-detected Agent"
-  });
-}
-function markExplicit(cardId) {
-  const existing = activeSessions.get(cardId);
-  if (existing) {
-    existing.isExplicit = true;
-  } else {
-    activeSessions.set(cardId, {
-      cardId,
-      startedAt: Date.now(),
-      lastActivityAt: Date.now(),
-      isExplicit: true,
-      agentIdentifier: "explicit",
-      agentName: "Explicit Agent"
-    });
-  }
-}
-function untrack(cardId) {
-  activeSessions.delete(cardId);
-}
-async function shutdownAllSessions() {
-  const client2 = clientGetter?.();
-  if (!client2)
-    return;
-  const cardIds = [...activeSessions.keys()];
-  const promises = cardIds.map((cardId) => autoEndSession(client2, cardId, "paused"));
-  await Promise.allSettled(promises);
-}
-function destroyAutoSession() {
-  if (inactivityTimer) {
-    clearInterval(inactivityTimer);
-    inactivityTimer = null;
-  }
-  activeSessions.clear();
-  endCallback = null;
-  clientGetter = null;
-}
-function checkInactivity() {
-  const now = Date.now();
-  const client2 = clientGetter?.();
-  if (!client2)
-    return;
-  const entries = [...activeSessions.entries()];
-  for (const [cardId, session] of entries) {
-    if (session.isExplicit)
-      continue;
-    if (now - session.lastActivityAt > INACTIVITY_TIMEOUT_MS) {
-      autoEndSession(client2, cardId, "completed").catch(() => {});
-    }
-  }
-}
-async function autoEndSession(client2, cardId, status) {
-  activeSessions.delete(cardId);
-  try {
-    await client2.endAgentSession(cardId, { status });
-  } catch {}
-  try {
-    await endCallback?.(client2, cardId, status);
-  } catch {}
-}
-
 // src/api-client.ts
 var RETRY_CONFIG = {
   maxRetries: 3,
@@ -24062,6 +24143,22 @@ class HarmonyApiClient {
     const query = params.toString() ? `?${params.toString()}` : "";
     return this.request("GET", `/cards/${cardId}/agent-context${query}`);
   }
+  async getAgentProfile(workspaceId, agentIdentifier) {
+    const params = new URLSearchParams({
+      workspace_id: workspaceId,
+      agent_identifier: agentIdentifier
+    });
+    return this.request("GET", `/agent-profiles?${params.toString()}`);
+  }
+  async listAgentProfiles(workspaceId) {
+    const params = new URLSearchParams({ workspace_id: workspaceId });
+    return this.request("GET", `/agent-profiles?${params.toString()}`);
+  }
+  async refreshAgentProfiles(workspaceId) {
+    return this.request("POST", "/agent-profiles/refresh", {
+      workspace_id: workspaceId
+    });
+  }
   async createMemoryEntity(data) {
     return this.request("POST", "/memory/entities", data);
   }
@@ -24265,6 +24362,125 @@ function resetClient() {
   client2 = null;
 }
 
+// src/auto-session.ts
+var AUTO_START_TRIGGERS = new Set([
+  "harmony_generate_prompt",
+  "harmony_update_card",
+  "harmony_move_card",
+  "harmony_create_subtask",
+  "harmony_toggle_subtask",
+  "harmony_add_label_to_card",
+  "harmony_remove_label_from_card"
+]);
+var INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
+var CHECK_INTERVAL_MS = 60 * 1000;
+var activeSessions = new Map;
+var inactivityTimer = null;
+var endCallback = null;
+var clientGetter = null;
+function initAutoSession(callback, getClient2) {
+  endCallback = callback;
+  clientGetter = getClient2;
+  if (inactivityTimer)
+    clearInterval(inactivityTimer);
+  inactivityTimer = setInterval(checkInactivity, CHECK_INTERVAL_MS);
+}
+async function trackActivity(cardId, options) {
+  const now = Date.now();
+  const existing = activeSessions.get(cardId);
+  if (existing) {
+    existing.lastActivityAt = now;
+    return;
+  }
+  if (!options?.autoStart)
+    return;
+  const client3 = options?.client ?? clientGetter?.();
+  if (!client3)
+    return;
+  const toEnd = [];
+  for (const [otherCardId, session] of activeSessions) {
+    if (otherCardId !== cardId && !session.isExplicit) {
+      toEnd.push(otherCardId);
+    }
+  }
+  for (const otherCardId of toEnd) {
+    await autoEndSession(client3, otherCardId, "completed");
+  }
+  try {
+    await client3.startAgentSession(cardId, {
+      agentIdentifier: "auto",
+      agentName: "Auto-detected Agent",
+      status: "working"
+    });
+  } catch {}
+  activeSessions.set(cardId, {
+    cardId,
+    startedAt: now,
+    lastActivityAt: now,
+    isExplicit: false,
+    agentIdentifier: "auto",
+    agentName: "Auto-detected Agent"
+  });
+}
+function markExplicit(cardId) {
+  const existing = activeSessions.get(cardId);
+  if (existing) {
+    existing.isExplicit = true;
+  } else {
+    activeSessions.set(cardId, {
+      cardId,
+      startedAt: Date.now(),
+      lastActivityAt: Date.now(),
+      isExplicit: true,
+      agentIdentifier: "explicit",
+      agentName: "Explicit Agent"
+    });
+  }
+}
+function untrack(cardId) {
+  activeSessions.delete(cardId);
+}
+async function shutdownAllSessions() {
+  const client3 = clientGetter?.();
+  if (!client3)
+    return;
+  const cardIds = [...activeSessions.keys()];
+  const promises = cardIds.map((cardId) => autoEndSession(client3, cardId, "paused"));
+  await Promise.allSettled(promises);
+}
+function destroyAutoSession() {
+  if (inactivityTimer) {
+    clearInterval(inactivityTimer);
+    inactivityTimer = null;
+  }
+  activeSessions.clear();
+  endCallback = null;
+  clientGetter = null;
+}
+function checkInactivity() {
+  const now = Date.now();
+  const client3 = clientGetter?.();
+  if (!client3)
+    return;
+  const entries = [...activeSessions.entries()];
+  for (const [cardId, session] of entries) {
+    if (session.isExplicit)
+      continue;
+    if (now - session.lastActivityAt > INACTIVITY_TIMEOUT_MS) {
+      autoEndSession(client3, cardId, "completed").catch(() => {});
+    }
+  }
+}
+async function autoEndSession(client3, cardId, status) {
+  activeSessions.delete(cardId);
+  try {
+    await client3.endAgentSession(cardId, { status });
+  } catch {}
+  try {
+    await endCallback?.(client3, cardId, status);
+  } catch {}
+}
+
 // src/consolidation.ts
 async function consolidateMemories(client3, workspaceId, projectId, options) {
   const dryRun = options?.dryRun !== false;
@@ -25926,6 +26142,22 @@ var TOOLS = {
       required: ["cardId"]
     }
   },
+  harmony_get_agent_profile: {
+    description: "Get aggregate performance profile for an agent. Shows total sessions, completion rate, average duration, and more. Defaults to the current agent if no identifier provided.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        agentIdentifier: {
+          type: "string",
+          description: "Agent identifier (e.g., 'claude-code'). Defaults to current agent."
+        },
+        workspaceId: {
+          type: "string",
+          description: "Workspace ID (optional if context set)"
+        }
+      }
+    }
+  },
   harmony_generate_prompt: {
     description: "Generate an AI-ready prompt from a card. Automatically infers role and focus based on labels (bug, feature, design, etc.). Use this to create context-rich prompts for working on cards.",
     inputSchema: {
@@ -26783,6 +27015,62 @@ async function runEndSessionPipeline(client3, deps, cardId, sessionStatus, endPr
     const learningResult = await extractLearnings(client3, sessionContext);
     learningsExtracted = learningResult.count;
   } catch {}
+  try {
+    const workspaceId = deps.getActiveWorkspaceId();
+    const agentId = sessionData?.agent_identifier || "unknown";
+    if (workspaceId && agentId !== "unknown") {
+      (async () => {
+        try {
+          await client3.refreshAgentProfiles(workspaceId);
+          const { profile } = await client3.getAgentProfile(workspaceId, agentId);
+          if (profile) {
+            const p = profile;
+            const title = `Agent Profile: ${agentId}`;
+            const content = [
+              `## ${agentId} Performance Profile`,
+              "",
+              `- **Total sessions:** ${p.total_sessions}`,
+              `- **Completed:** ${p.completed_sessions} (${p.completion_rate_pct}%)`,
+              `- **Paused:** ${p.paused_sessions}`,
+              `- **Blocked:** ${p.blocked_sessions}`,
+              `- **Avg duration:** ${Math.round(Number(p.avg_active_duration_ms || 0) / 1000)}s`,
+              `- **Avg progress:** ${p.avg_completion_progress}%`,
+              `- **First session:** ${p.first_session_at}`,
+              `- **Last session:** ${p.last_session_at}`
+            ].join(`
+`);
+            const existing = await client3.listMemoryEntities({
+              workspace_id: workspaceId,
+              type: "agent",
+              limit: 50
+            });
+            const entities = existing.entities || [];
+            const match = entities.find((e) => e.title === title || e.agent_identifier === agentId);
+            if (match) {
+              await client3.updateMemoryEntity(match.id, {
+                content,
+                confidence: 1,
+                metadata: p
+              });
+            } else {
+              await client3.createMemoryEntity({
+                workspace_id: workspaceId,
+                type: "agent",
+                scope: "workspace",
+                memory_tier: "reference",
+                title,
+                content,
+                confidence: 1,
+                tags: ["agent-profile", agentId],
+                agent_identifier: agentId,
+                metadata: p
+              });
+            }
+          }
+        } catch {}
+      })();
+    }
+  } catch {}
   try {
     const feedbackResult = await recordContextFeedback(client3, cardId, sessionStatus, endProgressPercent, (sessionData?.blockers?.length ?? 0) > 0);
     feedbackAdjusted = feedbackResult.adjusted;
@@ -27277,18 +27565,18 @@ async function handleToolCall(name, args, deps) {
       });
       untrack(cardId);
       let movedTo = null;
-      let learningsExtracted = 0;
-      let cardTitle = "";
-      let cardLabels = [];
-      let cardDescription = "";
-      let cardSubtasks = [];
+      const _learningsExtracted = 0;
+      let _cardTitle = "";
+      let _cardLabels = [];
+      let _cardDescription = "";
+      let _cardSubtasks = [];
       try {
         const { card } = await client3.getCard(cardId);
         const typedCard = card;
-        cardTitle = typedCard.title || "";
-        cardLabels = (typedCard.labels || []).map((l) => l.name);
-        cardDescription = typedCard.description || "";
-        cardSubtasks = (typedCard.subtasks || []).map((s) => ({
+        _cardTitle = typedCard.title || "";
+        _cardLabels = (typedCard.labels || []).map((l) => l.name);
+        _cardDescription = typedCard.description || "";
+        _cardSubtasks = (typedCard.subtasks || []).map((s) => ({
           title: s.title,
           done: s.done
         }));
@@ -27331,6 +27619,18 @@ async function handleToolCall(name, args, deps) {
       });
       return { success: true, ...result };
     }
+    case "harmony_get_agent_profile": {
+      const workspaceId = args.workspaceId || deps.getActiveWorkspaceId();
+      if (!workspaceId) {
+        return {
+          success: false,
+          error: "No workspace context. Provide workspaceId or set context."
+        };
+      }
+      const agentIdentifier = args.agentIdentifier || "claude-code";
+      const result = await client3.getAgentProfile(workspaceId, agentIdentifier);
+      return { success: true, ...result };
+    }
     case "harmony_generate_prompt": {
       let cardData;
       let columnData = null;

package/package.json

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