Add agent memory — persistent per-file context for AI sessions

Agents can now save and read a memory note tied to the current log
file so analysis can resume where it left off across sessions.

Storage: <logdir>/.logan/<filename>.agent-memory.json sidecar file.

Auto-inject on connect: when a named agent connects via /api/events
the SSE connected event includes the current memory payload so the
agent gets prior context without explicitly calling logan_memory_read.

MCP tools:
  logan_memory_read  — read the saved memory for the current file
  logan_memory_write — write/update the memory note

API endpoints:
  GET  /api/agent-memory        — read
  POST /api/agent-memory        — write (content + optional agentName)
  POST /api/agent-memory-clear  — delete

IPC: agent-memory-get/save/clear + agent-memory-changed push event.

UI: a compact memory bar in the Chat panel shows the agent name,
time ago, and a one-line preview of the last saved note. Disappears
when no memory exists for the current file; ✕ button to clear.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: ozgesolidkey

src/main/api-server.ts

@@ -68,6 +68,13 @@ export function getAgentName(): string | null {
   return getConnectedAgentName();
 }
 
+function notifyMemoryChanged(ctx: ApiContext): void {
+  const win = ctx.getMainWindow();
+  if (win && !win.isDestroyed()) {
+    win.webContents.send('agent-memory-changed', ctx.getAgentMemory());
+  }
+}
+
 function notifyAgentConnectionChanged(ctx: ApiContext): void {
   const connected = isAgentConnected();
   const name = getConnectedAgentName();
@@ -132,6 +139,9 @@ export interface ApiContext {
   clearHighlights(): any;
   loadNotes(): Promise<any>;
   saveNotes(content: string): Promise<any>;
+  getAgentMemory(): any;
+  saveAgentMemory(content: string, agentName?: string): any;
+  clearAgentMemory(): any;
   detectTimeGaps(options: any): Promise<any>;
   navigateToLine(lineNumber: number): void;
   getBaselineStore(): BaselineStore;
@@ -257,6 +267,12 @@ export function startApiServer(ctx: ApiContext): void {
           return;
         }
 
+        if (url === '/api/agent-memory') {
+          const mem = ctx.getAgentMemory();
+          sendJson(res, { success: true, memory: mem || null });
+          return;
+        }
+
         if (url === '/api/agent-status') {
           sendJson(res, {
             success: true,
@@ -283,7 +299,9 @@ export function startApiServer(ctx: ApiContext): void {
               sendJson(res, { success: false, error: 'Another agent is already connected', connectedAgent: activeAgent.name }, 409);
               return;
             }
-            res.write(`event: connected\ndata: ${JSON.stringify({ name: agentName })}\n\n`);
+            // Include any existing agent memory so the agent can resume context
+            const memory = ctx.getAgentMemory();
+            res.write(`event: connected\ndata: ${JSON.stringify({ name: agentName, memory: memory || null })}\n\n`);
             activeAgent = { res, name: agentName };
             notifyAgentConnectionChanged(ctx);
             req.on('close', () => {
@@ -497,6 +515,21 @@ export function startApiServer(ctx: ApiContext): void {
           return;
         }
 
+        if (url === '/api/agent-memory') {
+          if (body.content === undefined) return sendError(res, 'content required');
+          const ok = ctx.saveAgentMemory(body.content, body.agentName || activeAgent?.name);
+          notifyMemoryChanged(ctx);
+          sendJson(res, { success: ok });
+          return;
+        }
+
+        if (url === '/api/agent-memory-clear') {
+          ctx.clearAgentMemory();
+          notifyMemoryChanged(ctx);
+          sendJson(res, { success: true });
+          return;
+        }
+
         if (url === '/api/time-gaps') {
           const result = await ctx.detectTimeGaps({
             thresholdSeconds: body.thresholdSeconds ?? 30,

src/main/index.ts

@@ -892,6 +892,10 @@ app.whenReady().then(() => {
         return { success: true, content: '' };
       }
     },
+    getAgentMemory: () => getAgentMemory(currentFilePath),
+    saveAgentMemory: (content: string, agentName?: string) =>
+      saveAgentMemory(currentFilePath, content, agentName),
+    clearAgentMemory: () => clearAgentMemory(currentFilePath),
     saveNotes: async (content: string) => {
       if (!currentFilePath) return { success: false, error: 'No file open' };
       if (!ensureLocalLoganDir(currentFilePath)) {
@@ -3725,6 +3729,59 @@ ipcMain.handle('save-selected-lines', async (_, startLine: number, endLine: numb
   }
 });
 
+// === Agent Memory ===
+// Per-file persistent memory for AI agents. Stored alongside the log file so
+// agents can resume analysis across sessions.
+
+interface AgentMemoryData {
+  content: string;
+  agentName: string;
+  updatedAt: number;
+}
+
+function agentMemoryPath(filePath: string | null): string | null {
+  if (!filePath) return null;
+  return path.join(getLocalLoganDir(filePath), path.basename(filePath) + '.agent-memory.json');
+}
+
+function getAgentMemory(filePath: string | null): AgentMemoryData | null {
+  const p = agentMemoryPath(filePath);
+  if (!p) return null;
+  try { return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { return null; }
+}
+
+function saveAgentMemory(filePath: string | null, content: string, agentName?: string): boolean {
+  if (!filePath) return false;
+  if (!ensureLocalLoganDir(filePath)) return false;
+  const p = agentMemoryPath(filePath)!;
+  const data: AgentMemoryData = {
+    content,
+    agentName: agentName || 'Agent',
+    updatedAt: Date.now(),
+  };
+  try { fs.writeFileSync(p, JSON.stringify(data, null, 2), 'utf-8'); return true; } catch { return false; }
+}
+
+function clearAgentMemory(filePath: string | null): boolean {
+  const p = agentMemoryPath(filePath);
+  if (!p) return false;
+  try { if (fs.existsSync(p)) fs.unlinkSync(p); return true; } catch { return false; }
+}
+
+ipcMain.handle('agent-memory-get', () => {
+  const mem = getAgentMemory(currentFilePath);
+  return mem || null;
+});
+
+ipcMain.handle('agent-memory-save', (_e, content: string, agentName?: string) => {
+  const ok = saveAgentMemory(currentFilePath, content, agentName);
+  return { success: ok };
+});
+
+ipcMain.handle('agent-memory-clear', () => {
+  return { success: clearAgentMemory(currentFilePath) };
+});
+
 // === Save to Notes ===
 
 // Helper: Read notes file header to get source log path

src/mcp-server/index.ts

@@ -791,6 +791,33 @@ server.tool(
   }
 );
 
+// === Tool: logan_memory_read ===
+server.tool(
+  'logan_memory_read',
+  'Read the agent memory note for the current log file. Memory persists across sessions so you can resume analysis where you left off.',
+  {},
+  async () => {
+    const result = await apiCall('GET', '/api/agent-memory');
+    if (!result.memory) return { content: [{ type: 'text', text: 'No memory saved for this file yet.' }] };
+    const { content, agentName, updatedAt } = result.memory;
+    const ts = new Date(updatedAt).toLocaleString();
+    return { content: [{ type: 'text', text: `Memory saved by ${agentName} at ${ts}:\n\n${content}` }] };
+  }
+);
+
+// === Tool: logan_memory_write ===
+server.tool(
+  'logan_memory_write',
+  'Save a memory note for the current log file. Use this to record findings, progress, and next steps so you can resume analysis in a future session.',
+  {
+    content: z.string().describe('The memory content to save — findings, current status, next steps, etc.'),
+  },
+  async ({ content }) => {
+    await apiCall('POST', '/api/agent-memory', { content });
+    return { content: [{ type: 'text', text: 'Memory saved.' }] };
+  }
+);
+
 // === Tool: logan_remove_bookmark ===
 server.tool(
   'logan_remove_bookmark',

src/preload/index.ts

@@ -518,6 +518,18 @@ const api = {
     return () => ipcRenderer.removeListener('annotations-changed', handler);
   },
 
+  getAgentMemory: (): Promise<{ content: string; agentName: string; updatedAt: number } | null> =>
+    ipcRenderer.invoke('agent-memory-get'),
+  saveAgentMemory: (content: string, agentName?: string): Promise<{ success: boolean }> =>
+    ipcRenderer.invoke('agent-memory-save', content, agentName),
+  clearAgentMemory: (): Promise<{ success: boolean }> =>
+    ipcRenderer.invoke('agent-memory-clear'),
+  onAgentMemoryChanged: (callback: (memory: any) => void): (() => void) => {
+    const handler = (_: any, mem: any) => callback(mem);
+    ipcRenderer.on('agent-memory-changed', handler);
+    return () => ipcRenderer.removeListener('agent-memory-changed', handler);
+  },
+
   // Device discovery
   serialListPorts: (): Promise<{ success: boolean; ports?: any[]; error?: string }> =>
     ipcRenderer.invoke(IPC.SERIAL_LIST_PORTS),

src/renderer/index.html

@@ -630,6 +630,11 @@ <h2>LOGAN</h2>
               <button id="chat-launch-agent" class="chat-launch-btn">Launch Agent</button>
               <!-- Gear button removed — Launch Agent now always opens the wizard -->
             </div>
+            <div id="chat-memory-bar" class="chat-memory-bar hidden">
+              <span class="chat-memory-icon">🧠</span>
+              <span id="chat-memory-label" class="chat-memory-label">Memory saved</span>
+              <button id="btn-clear-agent-memory" class="chat-memory-clear" title="Clear agent memory">✕</button>
+            </div>
             <div id="chat-messages" class="chat-messages"></div>
             <div class="chat-input-bar">
               <input id="chat-input" type="text" placeholder="Message the AI agent..." />

src/renderer/renderer.ts

@@ -5159,6 +5159,8 @@ function openBottomTab(tabId: string): void {
     if (badge) badge.textContent = '';
     // Refresh agent connection status
     window.api.getAgentStatus().then((s: any) => updateAgentConnectionStatus(s.connected, s.count, s.name));
+    // Refresh memory bar
+    window.api.getAgentMemory().then((mem: any) => updateAgentMemoryBar(mem));
   }
   if (tabId === 'live') {
     refreshLiveDevices();
@@ -5684,6 +5686,29 @@ function updateAgentConnectionStatus(connected: boolean, count: number, name?: s
   }
 }
 
+function updateAgentMemoryBar(memory: { content: string; agentName: string; updatedAt: number } | null): void {
+  const bar = document.getElementById('chat-memory-bar');
+  const label = document.getElementById('chat-memory-label');
+  if (!bar || !label) return;
+  if (!memory) {
+    bar.classList.add('hidden');
+    return;
+  }
+  const ago = formatTimeAgo(memory.updatedAt);
+  const preview = memory.content.split('\n')[0].slice(0, 60);
+  label.textContent = `${memory.agentName} · ${ago} — ${preview}${memory.content.length > 60 ? '…' : ''}`;
+  label.title = memory.content;
+  bar.classList.remove('hidden');
+}
+
+function formatTimeAgo(ts: number): string {
+  const diff = Date.now() - ts;
+  if (diff < 60000) return 'just now';
+  if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+  if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+  return `${Math.floor(diff / 86400000)}d ago`;
+}
+
 let agentRunning = false;
 
 function updateLaunchButton(): void {
@@ -13223,6 +13248,16 @@ function init(): void {
       updateLaunchButton();
     }
   });
+  // Agent memory push listener
+  window.api.onAgentMemoryChanged((memory: any) => {
+    updateAgentMemoryBar(memory);
+  });
+
+  // Clear agent memory button
+  document.getElementById('btn-clear-agent-memory')?.addEventListener('click', async () => {
+    await window.api.clearAgentMemory();
+  });
+
   // Agent annotations push listener
   window.api.onAnnotationsChanged((anns: any[]) => {
     state.annotations = anns;

src/renderer/styles.css

@@ -4153,6 +4153,37 @@ kbd {
   font-style: italic;
 }
 
+.chat-memory-bar {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 10px;
+  background: rgba(100, 80, 180, 0.12);
+  border-bottom: 1px solid rgba(100, 80, 180, 0.25);
+  font-size: 11px;
+  color: var(--text-secondary);
+  min-height: 0;
+}
+.chat-memory-bar.hidden { display: none; }
+.chat-memory-icon { font-size: 13px; flex-shrink: 0; }
+.chat-memory-label {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  cursor: default;
+}
+.chat-memory-clear {
+  background: none;
+  border: none;
+  color: var(--text-muted);
+  cursor: pointer;
+  font-size: 11px;
+  padding: 0 2px;
+  flex-shrink: 0;
+}
+.chat-memory-clear:hover { color: var(--error-color); }
+
 .chat-launch-btn {
   background: var(--accent-color, #007acc);
   color: #fff;

src/renderer/types.d.ts

@@ -470,6 +470,11 @@ interface Api {
   clearAnnotations: () => Promise<{ success: boolean }>;
   onAnnotationsChanged: (callback: (annotations: any[]) => void) => () => void;
 
+  getAgentMemory: () => Promise<{ content: string; agentName: string; updatedAt: number } | null>;
+  saveAgentMemory: (content: string, agentName?: string) => Promise<{ success: boolean }>;
+  clearAgentMemory: () => Promise<{ success: boolean }>;
+  onAgentMemoryChanged: (callback: (memory: any) => void) => () => void;
+
   // Device discovery
   serialListPorts: () => Promise<{ success: boolean; ports?: Array<{ path: string; manufacturer?: string; vendorId?: string; productId?: string }>; error?: string }>;
   logcatListDevices: () => Promise<{ success: boolean; devices?: Array<{ id: string; state: string; model?: string }>; error?: string }>;