@gethmy/mcp 2.1.3 → 2.2.1

package/dist/lib/server.js

@@ -11,7 +11,118 @@ 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, {
+        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 +1708,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 +2055,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 +2124,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 +2142,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 +2173,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,
@@ -2133,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);
@@ -2148,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 =
@@ -2188,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,
             };
         }
@@ -2270,6 +2320,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 +2335,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 +2355,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 +2430,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 +2455,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 +2509,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 +2530,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 +2634,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,
@@ -3092,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/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.1",
   "description": "MCP server for Harmony Kanban board - enables AI coding agents to manage your boards",
   "publishConfig": {
     "access": "public"

package/src/__tests__/auto-session.test.ts

@@ -51,16 +51,16 @@ describe("auto-start", () => {
 
     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 () => {
@@ -109,7 +109,7 @@ describe("auto-start", () => {
 
     // 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 () => {
@@ -328,8 +328,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();
@@ -355,8 +355,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();
@@ -398,8 +398,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
@@ -408,8 +408,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
@@ -442,8 +442,8 @@ describe("inactivity timeout", () => {
       startedAt: 0,
       lastActivityAt: 0,
       isExplicit: false,
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
+      agentIdentifier: "unknown",
+      agentName: "Unknown Agent",
     });
 
     // Should not throw
@@ -464,8 +464,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
@@ -495,8 +495,8 @@ describe("markExplicit", () => {
 
     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", () => {
@@ -583,8 +583,8 @@ describe("shutdown", () => {
       startedAt: Date.now(),
       lastActivityAt: Date.now(),
       isExplicit: false,
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
+      agentIdentifier: "unknown",
+      agentName: "Unknown Agent",
     });
 
     await shutdownAllSessions();
@@ -606,8 +606,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,
@@ -633,8 +633,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
@@ -660,16 +660,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();
@@ -826,8 +826,8 @@ describe("edge cases", () => {
       startedAt: 0,
       lastActivityAt: 0,
       isExplicit: false,
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
+      agentIdentifier: "unknown",
+      agentName: "Unknown Agent",
     });
 
     checkInactivity();
@@ -850,8 +850,8 @@ describe("edge cases", () => {
       startedAt: 0,
       lastActivityAt: 0,
       isExplicit: false,
-      agentIdentifier: "auto",
-      agentName: "Auto-detected Agent",
+      agentIdentifier: "unknown",
+      agentName: "Unknown Agent",
     });
 
     checkInactivity();