cf-memory-mcp 3.64.0 → 3.65.0

package/bin/cf-memory-mcp.js

@@ -4710,6 +4710,62 @@ async function runResumeCli() {
             } else {
                 process.stdout.write(JSON.stringify(payload.resume_handoff, null, 2) + '\n');
             }
+            // Branch state: if the handoff's repo matches cwd and there
+            // are uncommitted changes (especially in files_touched),
+            // surface them so the agent knows work was interrupted mid-
+            // edit. Quiet when the tree is clean to avoid noise. Skip
+            // entirely when env var disables it.
+            if (process.env.CF_MEMORY_BRANCH_STATE !== 'off') {
+                try {
+                    const meta = server.getRepoMetadata();
+                    const handoffRepo = payload.resume_handoff?.handoff?.repo_path
+                        || payload.resume_handoff?.repo_path;
+                    if (meta.repo_path && handoffRepo && meta.repo_path === handoffRepo) {
+                        const { execSync } = require('child_process');
+                        const dirty = execSync('git status --porcelain', { cwd: meta.repo_path, encoding: 'utf8', timeout: 2000 })
+                            .split('\n').filter(Boolean);
+                        if (dirty.length > 0) {
+                            const filesTouched = Array.isArray(payload.resume_handoff?.handoff?.files_touched)
+                                ? payload.resume_handoff.handoff.files_touched
+                                    .map(ft => typeof ft === 'string' ? ft : ft?.path)
+                                    .filter(Boolean)
+                                : [];
+                            const inHandoff = new Set(filesTouched);
+                            const matched = dirty.filter(line => {
+                                const p = line.slice(3);
+                                return inHandoff.has(p);
+                            });
+                            const otherCount = dirty.length - matched.length;
+                            process.stdout.write('\n### Branch state (since handoff was written)\n');
+                            if (matched.length > 0) {
+                                process.stdout.write(`Mid-edit on ${matched.length} of your files_touched:\n`);
+                                for (const line of matched.slice(0, 8)) {
+                                    process.stdout.write(`  ${line}\n`);
+                                }
+                                if (matched.length > 8) {
+                                    process.stdout.write(`  ... and ${matched.length - 8} more\n`);
+                                }
+                            }
+                            if (otherCount > 0) {
+                                process.stdout.write(`Plus ${otherCount} other uncommitted file${otherCount === 1 ? '' : 's'} in the tree (run \`git status\` for full list).\n`);
+                            }
+                            // Also check if HEAD has advanced past the handoff time.
+                            try {
+                                const handoffTime = payload.resume_handoff?.ended_at
+                                    || payload.resume_handoff?.started_at;
+                                if (handoffTime) {
+                                    const since = `--since="${handoffTime}"`;
+                                    const newCommits = execSync(`git log ${since} --oneline 2>/dev/null | wc -l`, { cwd: meta.repo_path, encoding: 'utf8', timeout: 2000, shell: '/bin/sh' }).trim();
+                                    const n = parseInt(newCommits, 10);
+                                    if (Number.isFinite(n) && n > 0) {
+                                        process.stdout.write(`${n} commit${n === 1 ? '' : 's'} on this branch since handoff (\`git log --since="${handoffTime}"\` to see them).\n`);
+                                    }
+                                }
+                            } catch (_) { /* commit-count is best-effort */ }
+                        }
+                    }
+                } catch (_) { /* git unavailable or non-repo — silent */ }
+            }
             // --include-chain N: walk parent_session_id back N times and
             // append each parent's resume_prompt inline so the agent sees
             // the full thread arc in one output.
@@ -4737,12 +4793,32 @@ async function runResumeCli() {
                 }
             }
             if (Array.isArray(payload.recent_handoffs) && payload.recent_handoffs.length > 1) {
-                process.stdout.write('\n---\nOther recent handoffs:\n');
-                for (const h of payload.recent_handoffs.slice(0, 4)) {
-                    const shortId = (h.session_id || '').slice(0, 8);
-                    process.stdout.write(`  ${shortId} [${h.status || '?'}] ${h.goal || ''}\n`);
+                // Dedupe: skip the primary handoff (already shown) and
+                // collapse near-duplicate auto-checkpoints — entries that
+                // share normalized (goal, branch, status). Keep the most
+                // recent occurrence of each unique key. This removes
+                // visible noise from 30+ in_progress sessions all named
+                // "Re-verify enrichment+freshness" on the same branch.
+                const primaryId = payload.resume_handoff?.session_id;
+                const norm = (s) => (s || '').toLowerCase().replace(/\s+/g, ' ').trim();
+                const seen = new Set();
+                const unique = [];
+                for (const h of payload.recent_handoffs) {
+                    if (h.session_id === primaryId) continue;
+                    const key = `${norm(h.goal)}|${norm(h.branch)}|${h.status || ''}`;
+                    if (seen.has(key)) continue;
+                    seen.add(key);
+                    unique.push(h);
+                    if (unique.length >= 4) break;
+                }
+                if (unique.length > 0) {
+                    process.stdout.write('\n---\nOther recent handoffs:\n');
+                    for (const h of unique) {
+                        const shortId = (h.session_id || '').slice(0, 8);
+                        process.stdout.write(`  ${shortId} [${h.status || '?'}] ${h.goal || ''}\n`);
+                    }
+                    process.stdout.write(`(Pass any short id as: npx cf-memory-mcp resume <id>)\n`);
                 }
-                process.stdout.write(`(Pass any short id as: npx cf-memory-mcp resume <id>)\n`);
             }
             process.exit(0);
         } else {
@@ -5480,6 +5556,7 @@ function runEnvCli() {
         ['CF_MEMORY_SHUTDOWN_HANDOFF', 'default: on; "off" disables the SIGINT/SIGTERM handoff flush'],
         ['CF_MEMORY_PREWARM_RESUME', 'default: on; "off" disables the background resume prewarm at bridge startup'],
         ['CF_MEMORY_RESUME_DIFF', 'default: on; "off" disables git-diff injection into resume responses'],
+        ['CF_MEMORY_BRANCH_STATE', 'default: on; "off" disables the "Branch state (since handoff was written)" block in `cfm resume`'],
         ['CF_MEMORY_DISK_CACHE', 'default: on; "off" disables ~/.cf-memory/handoff-*.json disk caching'],
         ['CF_MEMORY_NO_RETRY', 'default: off; "1" disables the single retry-on-transient-failure'],
         ['CF_MEMORY_LOG', 'default: off; "1" writes DEBUG/ERROR lines to ~/.cf-memory/bridge.log'],

package/package.json

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