cf-memory-mcp 3.10.1 → 3.11.0

package/bin/cf-memory-mcp.js

@@ -792,6 +792,11 @@ class CFMemoryMCP {
                 await this.maybeAttachResumeMetadata(message);
             }
 
+            // Record which files the agent is touching so end_session can
+            // auto-populate handoff.files_read. Cheap (in-memory Map), safe
+            // (try/catch'd), and the agent's hand-written list always wins.
+            this.trackToolActivity(message);
+
             let response = await this.makeRequest(message);
             _mcpTrace('DISPATCH_DONE', `id=${message.id} method=${message.method} elapsed=${Date.now()-_t0}ms`);
 
@@ -801,6 +806,9 @@ class CFMemoryMCP {
             // acting on stale indexed content as if it were current.
             if (message.method === 'tools/call' &&
                 message.params && message.params.name === 'retrieve_context') {
+                // Track which files the response surfaced — these are what
+                // the agent will read next, and they belong in handoff.files_read.
+                this.trackRetrieveContextResponse(response);
                 this.maybeAnnotateStaleness(response, message.params.arguments);
 
                 // Auto-refresh path: when CF_MEMORY_AUTO_REFRESH=true OR the
@@ -2122,6 +2130,11 @@ class CFMemoryMCP {
                         args.handoff.project_id = fake.params.arguments.project_id;
                     }
                 }
+                // Auto-fill files_read from observed retrieve_context /
+                // get_file_content / get_file_outline calls during this
+                // bridge session, if the agent didn't supply them. The
+                // agent's hand-written files_touched stays authoritative.
+                this.autoFillHandoffFilesRead(args.handoff);
                 return;
             }
         } catch (err) {
@@ -2129,6 +2142,107 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Record file paths the agent touched via retrieve_context, get_file_content,
+     * get_file_outline, and refresh_files. Used to seed end_session.handoff.files_read
+     * when the agent didn't bother listing them. The set is bounded so a chatty
+     * session can't blow up memory.
+     */
+    trackToolActivity(message) {
+        try {
+            if (message?.method !== 'tools/call' || !message.params) return;
+            const toolName = message.params.name;
+            const args = message.params.arguments || {};
+            if (!this._activityFiles) this._activityFiles = new Map();
+
+            const noteFile = (file_path, source) => {
+                if (typeof file_path !== 'string' || !file_path) return;
+                // Bound to 50 entries — past that we drop oldest.
+                if (this._activityFiles.size >= 50 && !this._activityFiles.has(file_path)) {
+                    const firstKey = this._activityFiles.keys().next().value;
+                    this._activityFiles.delete(firstKey);
+                }
+                const existing = this._activityFiles.get(file_path) || { sources: new Set(), count: 0 };
+                existing.sources.add(source);
+                existing.count += 1;
+                existing.last_seen = Date.now();
+                this._activityFiles.set(file_path, existing);
+            };
+
+            if (toolName === 'get_file_content' || toolName === 'get_file_outline') {
+                noteFile(args.file_path, toolName);
+            } else if (toolName === 'refresh_files' && Array.isArray(args.file_paths)) {
+                for (const p of args.file_paths) noteFile(p, 'refresh_files');
+            }
+        } catch (err) {
+            this.logDebug(`trackToolActivity failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Record file paths from a retrieve_context response. Called after the
+     * server responds so we capture what was actually returned (not just
+     * what was queried for).
+     */
+    trackRetrieveContextResponse(response) {
+        try {
+            if (!this._activityFiles) this._activityFiles = new Map();
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            let parsed;
+            try { parsed = JSON.parse(text); } catch (_) { return; }
+            const results = Array.isArray(parsed?.results) ? parsed.results : [];
+            for (const r of results.slice(0, 20)) {
+                if (typeof r?.file_path !== 'string') continue;
+                if (this._activityFiles.size >= 50 && !this._activityFiles.has(r.file_path)) {
+                    const firstKey = this._activityFiles.keys().next().value;
+                    this._activityFiles.delete(firstKey);
+                }
+                const existing = this._activityFiles.get(r.file_path) || { sources: new Set(), count: 0 };
+                existing.sources.add('retrieve_context');
+                existing.count += 1;
+                existing.last_seen = Date.now();
+                this._activityFiles.set(r.file_path, existing);
+            }
+        } catch (err) {
+            this.logDebug(`trackRetrieveContextResponse failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Populate handoff.files_read from observed tool activity, but only
+     * when the agent did not already list any. Hand-written entries always
+     * win — the bridge is a fallback, not a replacement.
+     */
+    autoFillHandoffFilesRead(handoff) {
+        try {
+            if (!handoff || typeof handoff !== 'object') return;
+            if (Array.isArray(handoff.files_read) && handoff.files_read.length > 0) return;
+            if (!this._activityFiles || this._activityFiles.size === 0) return;
+
+            // Exclude files the agent already listed as touched — those
+            // outrank "read". Then take the top 20 by access count.
+            const touchedPaths = new Set(
+                Array.isArray(handoff.files_touched)
+                    ? handoff.files_touched.map(f => f.path).filter(Boolean)
+                    : []
+            );
+            const entries = Array.from(this._activityFiles.entries())
+                .filter(([p]) => !touchedPaths.has(p))
+                .sort((a, b) => b[1].count - a[1].count)
+                .slice(0, 20);
+            if (entries.length === 0) return;
+
+            handoff.files_read = entries.map(([path, info]) => ({
+                path,
+                why: `Observed via ${Array.from(info.sources).join(', ')} (${info.count}x)`,
+            }));
+            _mcpTrace('HANDOFF_AUTOFILL', `files_read=${entries.length}`);
+        } catch (err) {
+            this.logDebug(`autoFillHandoffFilesRead failed: ${err && err.message}`);
+        }
+    }
+
     /**
      * If the just-returned retrieve_context response had stale files,
      * refresh them via refreshFilesCore, re-run the original query, and

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.10.1",
+	"version": "3.11.0",
 	"description": "Cloudflare-hosted MCP server for code indexing, retrieval, and assistant memory with a direct remote MCP endpoint and local stdio bridge.",
 	"main": "bin/cf-memory-mcp.js",
 	"bin": {