cf-memory-mcp 3.12.0 → 3.13.0

package/bin/cf-memory-mcp.js

@@ -843,6 +843,13 @@ class CFMemoryMCP {
             // Send response to stdout
             process.stdout.write(JSON.stringify(response) + '\n');
 
+            // Safety net: every N tool calls, if there's an active implicit
+            // session AND tracked activity, fire a background auto-checkpoint
+            // with a synthesized handoff. Catches agents that forget to call
+            // end_session before a crash or timeout. Fire-and-forget so it
+            // doesn't slow down the real response.
+            this.maybeAutoCheckpoint();
+
         } catch (error) {
             this.logError('Error handling message:', error);
             _mcpTrace('ERROR', `${error.message} elapsed=${Date.now()-_t0}ms`);
@@ -2302,11 +2309,85 @@ class CFMemoryMCP {
             } else if (toolName === 'refresh_files' && Array.isArray(args.file_paths)) {
                 for (const p of args.file_paths) noteFile(p, 'refresh_files');
             }
+
+            // Remember the most recent retrieve_context query so auto-checkpoints
+            // have something concrete to put in the synthesized handoff.goal.
+            if (toolName === 'retrieve_context' && typeof args.query === 'string' && args.query.trim()) {
+                this._lastRetrieveQuery = args.query.trim();
+            }
+
+            // Tool-call counter for auto-checkpoint safety net. Counts all
+            // tool/call messages; auto-checkpoint fires every N calls.
+            this._toolCallCount = (this._toolCallCount || 0) + 1;
         } catch (err) {
             this.logDebug(`trackToolActivity failed: ${err && err.message}`);
         }
     }
 
+    /**
+     * Fire-and-forget auto-checkpoint. Every N tool calls, if there's an
+     * active implicit session AND there's been meaningful activity, send a
+     * background end_session({keep_open:true}) with a synthesized handoff.
+     * This is the safety net for agents that forget (or crash) before
+     * calling end_session manually.
+     *
+     * Behavior:
+     *   - Only fires when an implicit session exists (no surprise creation)
+     *   - Synthesizes handoff.goal from the last retrieve_context query
+     *   - Pulls files_read from activity tracker
+     *   - keep_open=true so the user can still finalize properly
+     *   - Failures are silent — never blocks the real tool call
+     */
+    async maybeAutoCheckpoint() {
+        try {
+            const intervalEnv = parseInt(process.env.CF_MEMORY_CHECKPOINT_EVERY || '25', 10);
+            const interval = Number.isFinite(intervalEnv) && intervalEnv > 0 ? intervalEnv : 25;
+            const opt = process.env.CF_MEMORY_AUTO_CHECKPOINT;
+            // Opt-out by env. Default is on. Set to 0/false/off to disable.
+            const enabled = !(opt === '0' || opt === 'false' || opt === 'off');
+            if (!enabled) return;
+            const count = this._toolCallCount || 0;
+            if (count === 0 || count % interval !== 0) return;
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            const sessionId = this._implicitSessionByCwd?.get(cwd);
+            if (!sessionId) return; // no implicit session, nothing to checkpoint
+            // Require at least one tracked file so we don't spam empty handoffs.
+            if (!this._activityFiles || this._activityFiles.size === 0) return;
+
+            // Synthesize handoff.
+            const meta = this.getRepoMetadata();
+            const fake = { params: { name: 'retrieve_context', arguments: {} } };
+            await this.maybeFillProjectId(fake);
+            const handoff = {
+                goal: this._lastRetrieveQuery
+                    ? `Working on: ${this._lastRetrieveQuery.slice(0, 120)}`
+                    : `Auto-checkpoint at ${count} tool calls`,
+                status: 'in_progress',
+            };
+            if (meta.repo_path) handoff.repo_path = meta.repo_path;
+            if (meta.branch) handoff.branch = meta.branch;
+            if (fake.params.arguments.project_id) handoff.project_id = fake.params.arguments.project_id;
+            this.autoFillHandoffFilesRead(handoff);
+
+            // Fire-and-forget — don't block the real response on this.
+            // Awaiting would serialise auto-checkpoint behind the main
+            // request path. Failures are logged at debug only.
+            this.makeRequest({
+                jsonrpc: '2.0',
+                id: `auto-checkpoint-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'end_session', arguments: {
+                    session_id: sessionId,
+                    keep_open: true,
+                    handoff,
+                } },
+            }).catch(err => this.logDebug(`auto-checkpoint failed: ${err && err.message}`));
+            _mcpTrace('AUTO_CHECKPOINT', `session=${sessionId} after ${count} calls files=${this._activityFiles.size}`);
+        } catch (err) {
+            this.logDebug(`maybeAutoCheckpoint 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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.12.0",
+	"version": "3.13.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": {