Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(hooks): persist real session-end state (#3077)

Wu Shuwen02eae9c1174f
diff --git a/v3/@claude-flow/cli/__tests__/issue-2691-session-end-cleanup.test.ts b/v3/@claude-flow/cli/__tests__/issue-2691-session-end-cleanup.test.ts
index d928d4a9f1..4732510932 100644
--- a/v3/@claude-flow/cli/__tests__/issue-2691-session-end-cleanup.test.ts
+++ b/v3/@claude-flow/cli/__tests__/issue-2691-session-end-cleanup.test.ts
@@ -1,4 +1,7 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
const bridgeSessionEnd = vi.fn();
const shutdownBridge = vi.fn();
@@ -11,13 +14,32 @@ vi.mock('../src/memory/memory-bridge.js', () => ({
import { hooksSessionEnd } from '../src/mcp-tools/hooks-tools.js';
describe('hooks session-end native resource cleanup (#2691)', () => {
+ let workdir: string;
+ let previousCwd: string | undefined;
+
beforeEach(() => {
+ workdir = mkdtempSync(join(tmpdir(), 'ruflo-2691-'));
+ previousCwd = process.env.CLAUDE_FLOW_CWD;
+ process.env.CLAUDE_FLOW_CWD = workdir;
+ const sessionDir = join(workdir, '.claude-flow', 'sessions');
+ mkdirSync(sessionDir, { recursive: true });
+ writeFileSync(join(sessionDir, 'current.json'), JSON.stringify({
+ id: 'session-cleanup-test',
+ startedAt: new Date(Date.now() - 60_000).toISOString(),
+ metrics: { edits: 0, commands: 0, tasks: 0, errors: 0 },
+ }));
bridgeSessionEnd.mockReset();
shutdownBridge.mockReset();
bridgeSessionEnd.mockResolvedValue({ controller: 'test', persisted: true });
shutdownBridge.mockResolvedValue(undefined);
});
+ afterEach(() => {
+ rmSync(workdir, { recursive: true, force: true });
+ if (previousCwd === undefined) delete process.env.CLAUDE_FLOW_CWD;
+ else process.env.CLAUDE_FLOW_CWD = previousCwd;
+ });
+
it('shuts down the memory bridge after persisting a session', async () => {
const result = await hooksSessionEnd.handler({ saveState: false, stopDaemon: false });
diff --git a/v3/@claude-flow/cli/__tests__/issue-3063-session-end-state.test.ts b/v3/@claude-flow/cli/__tests__/issue-3063-session-end-state.test.ts
new file mode 100644
index 0000000000..c303bb73e1
--- /dev/null
+++ b/v3/@claude-flow/cli/__tests__/issue-3063-session-end-state.test.ts
@@ -0,0 +1,119 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const bridgeSessionEnd = vi.fn();
+const shutdownBridge = vi.fn();
+
+vi.mock('../src/memory/memory-bridge.js', () => ({
+ bridgeSessionEnd,
+ shutdownBridge,
+}));
+
+import { hooksSessionEnd } from '../src/mcp-tools/hooks-tools.js';
+
+describe('hooks session-end real session state (#3063)', () => {
+ const now = new Date('2026-08-21T10:00:00.000Z');
+ const startedAt = new Date('2026-08-21T09:50:00.000Z');
+ const beforeSession = new Date('2026-08-21T09:40:00.000Z');
+ let workdir: string;
+ let previousCwd: string | undefined;
+
+ beforeEach(() => {
+ vi.useFakeTimers();
+ vi.setSystemTime(now);
+ workdir = mkdtempSync(join(tmpdir(), 'ruflo-3063-'));
+ previousCwd = process.env.CLAUDE_FLOW_CWD;
+ process.env.CLAUDE_FLOW_CWD = workdir;
+
+ for (const directory of ['sessions', 'tasks', 'memory']) {
+ mkdirSync(join(workdir, '.claude-flow', directory), { recursive: true });
+ }
+
+ writeFileSync(join(workdir, '.claude-flow', 'sessions', 'current.json'), JSON.stringify({
+ id: 'session-real-3063',
+ startedAt: startedAt.toISOString(),
+ metrics: { edits: 4, commands: 2, tasks: 3, errors: 1 },
+ }));
+ writeFileSync(join(workdir, '.claude-flow', 'tasks', 'store.json'), JSON.stringify({
+ version: '3.0.0',
+ tasks: {
+ completedNow: { status: 'completed', completedAt: '2026-08-21T09:55:00.000Z' },
+ failedNow: { status: 'failed', completedAt: '2026-08-21T09:56:00.000Z' },
+ completedBefore: { status: 'completed', completedAt: beforeSession.toISOString() },
+ pending: { status: 'pending', completedAt: null },
+ },
+ }));
+ writeFileSync(join(workdir, '.claude-flow', 'memory', 'store.json'), JSON.stringify({
+ version: '3.0.0',
+ entries: {
+ learnedNow: {
+ key: 'routing-decision:reviewer',
+ value: { success: true },
+ namespace: 'patterns',
+ metadata: { type: 'routing-decision' },
+ storedAt: '2026-08-21T09:57:00.000Z',
+ accessCount: 0,
+ lastAccessed: '2026-08-21T09:57:00.000Z',
+ },
+ oldPattern: {
+ key: 'pattern-old',
+ value: 'old',
+ storedAt: beforeSession.toISOString(),
+ accessCount: 0,
+ lastAccessed: beforeSession.toISOString(),
+ },
+ misleadingTaskKey: {
+ key: 'task-not-a-completed-task',
+ value: 'not a task record or pattern',
+ storedAt: '2026-08-21T09:58:00.000Z',
+ accessCount: 0,
+ lastAccessed: '2026-08-21T09:58:00.000Z',
+ },
+ },
+ }));
+
+ bridgeSessionEnd.mockReset();
+ shutdownBridge.mockReset();
+ bridgeSessionEnd.mockResolvedValue({ controller: 'test', persisted: true });
+ shutdownBridge.mockResolvedValue(undefined);
+ });
+
+ afterEach(() => {
+ vi.useRealTimers();
+ rmSync(workdir, { recursive: true, force: true });
+ if (previousCwd === undefined) delete process.env.CLAUDE_FLOW_CWD;
+ else process.env.CLAUDE_FLOW_CWD = previousCwd;
+ });
+
+ it('persists the active session id with session-scoped task and pattern counts', async () => {
+ const result = await hooksSessionEnd.handler({ saveState: true, stopDaemon: false }) as Record<string, any>;
+
+ expect(bridgeSessionEnd).toHaveBeenCalledWith(expect.objectContaining({
+ sessionId: 'session-real-3063',
+ tasksCompleted: 1,
+ patternsLearned: 1,
+ summary: '1 task completed; 1 pattern learned; 4 edits recorded; 2 commands recorded; 1 error recorded; duration 10 minutes',
+ }));
+ expect(result).toMatchObject({
+ sessionId: 'session-real-3063',
+ duration: 600_000,
+ statePath: '.claude/sessions/session-real-3063.json',
+ summary: {
+ tasksExecuted: 1,
+ filesModified: 4,
+ agentsSpawned: 0,
+ },
+ learningUpdates: { patternsLearned: 1 },
+ });
+ });
+
+ it('refuses to fabricate an id when no active session exists', async () => {
+ unlinkSync(join(workdir, '.claude-flow', 'sessions', 'current.json'));
+
+ await expect(hooksSessionEnd.handler({ saveState: true, stopDaemon: false }))
+ .rejects.toThrow('No active session state found');
+ expect(bridgeSessionEnd).not.toHaveBeenCalled();
+ });
+});
diff --git a/v3/@claude-flow/cli/src/mcp-tools/hooks-tools.ts b/v3/@claude-flow/cli/src/mcp-tools/hooks-tools.ts
index c6c0e85b4a..66da00301e 100644
--- a/v3/@claude-flow/cli/src/mcp-tools/hooks-tools.ts
+++ b/v3/@claude-flow/cli/src/mcp-tools/hooks-tools.ts
@@ -494,7 +494,7 @@ const MEMORY_DIR = '.claude-flow/memory';
const MEMORY_FILE = 'store.json';
function getMemoryPath(): string {
- return resolve(join(MEMORY_DIR, MEMORY_FILE));
+ return resolve(join(getProjectCwd(), MEMORY_DIR, MEMORY_FILE));
}
function loadMemoryStore(): MemoryStore {
@@ -510,6 +510,105 @@ function loadMemoryStore(): MemoryStore {
return { entries: {}, version: '3.0.0' };
}
+interface ActiveSessionState {
+ id: string;
+ startedAt: string;
+ metrics?: {
+ edits?: number;
+ commands?: number;
+ tasks?: number;
+ errors?: number;
+ };
+}
+
+interface SessionActivity {
+ tasksCompleted: number;
+ patternsLearned: number;
+ editsRecorded: number;
+ commandsRecorded: number;
+ errorsRecorded: number;
+}
+
+function isLearnedPatternEntry(entry: MemoryEntry): boolean {
+ return entry.key.includes('pattern') ||
+ entry.metadata?.type === 'pattern' ||
+ entry.key.startsWith('learned-') ||
+ entry.namespace === 'patterns' ||
+ entry.metadata?.type === 'routing-decision';
+}
+
+function timestampInRange(value: unknown, start: number, end: number): boolean {
+ if (typeof value !== 'string' && typeof value !== 'number') return false;
+ const timestamp = typeof value === 'number' ? value : Date.parse(value);
+ return Number.isFinite(timestamp) && timestamp >= start && timestamp <= end;
+}
+
+function nonNegativeInteger(value: unknown): number {
+ return typeof value === 'number' && Number.isFinite(value)
+ ? Math.max(0, Math.floor(value))
+ : 0;
+}
+
+function loadActiveSessionState(): ActiveSessionState | null {
+ try {
+ const sessionPath = join(getProjectCwd(), '.claude-flow', 'sessions', 'current.json');
+ if (!existsSync(sessionPath)) return null;
+ const session = JSON.parse(readFileSync(sessionPath, 'utf-8')) as Partial<ActiveSessionState>;
+ if (typeof session.id !== 'string' || session.id.trim().length === 0) return null;
+ if (typeof session.startedAt !== 'string' || !Number.isFinite(Date.parse(session.startedAt))) return null;
+ return session as ActiveSessionState;
+ } catch {
+ return null;
+ }
+}
+
+function loadSessionActivity(session: ActiveSessionState, endedAt: number): SessionActivity {
+ const startedAt = Date.parse(session.startedAt);
+ let tasksCompleted = 0;
+
+ try {
+ const taskPath = join(getProjectCwd(), '.claude-flow', 'tasks', 'store.json');
+ if (existsSync(taskPath)) {
+ const store = JSON.parse(readFileSync(taskPath, 'utf-8')) as {
+ tasks?: Record<string, { status?: string; completedAt?: string }>;
+ };
+ for (const task of Object.values(store.tasks ?? {})) {
+ if (task.status === 'completed' && timestampInRange(task.completedAt, startedAt, endedAt)) {
+ tasksCompleted++;
+ }
+ }
+ }
+ } catch {
+ // Missing or malformed task state contributes no completed tasks.
+ }
+
+ const patternsLearned = Object.values(loadMemoryStore().entries)
+ .filter(entry => isLearnedPatternEntry(entry) && timestampInRange(entry.storedAt, startedAt, endedAt))
+ .length;
+
+ return {
+ tasksCompleted,
+ patternsLearned,
+ editsRecorded: nonNegativeInteger(session.metrics?.edits),
+ commandsRecorded: nonNegativeInteger(session.metrics?.commands),
+ errorsRecorded: nonNegativeInteger(session.metrics?.errors),
+ };
+}
+
+function buildSessionSummary(activity: SessionActivity, duration: number): string {
+ const durationMinutes = Math.max(0, Math.round(duration / 60000));
+ const count = (value: number, singular: string, plural = `${singular}s`) =>
+ `${value} ${value === 1 ? singular : plural}`;
+ return [
+ `${count(activity.tasksCompleted, 'task')} completed`,
+ `${count(activity.patternsLearned, 'pattern')} learned`,
+ `${count(activity.editsRecorded, 'edit')} recorded`,
+ `${count(activity.commandsRecorded, 'command')} recorded`,
+ `${count(activity.errorsRecorded, 'error')} recorded`,
+ `duration ${count(durationMinutes, 'minute')}`,
+ ].join('; ');
+}
+
/**
* Get real intelligence statistics from memory store
*/
@@ -549,13 +648,7 @@ function getIntelligenceStatsFromMemory(): {
// patterns the metric is meant to count, so include them: any entry
// whose namespace is `patterns`, plus the original shapes for
// forward-compatibility with a future explicit `pattern` writer.
- const patternEntries = entries.filter(e =>
- e.key.includes('pattern') ||
- e.metadata?.type === 'pattern' ||
- e.key.startsWith('learned-') ||
- e.namespace === 'patterns' ||
- e.metadata?.type === 'routing-decision'
- );
+ const patternEntries = entries.filter(isLearnedPatternEntry);
// Categorize patterns
const categories: Record<string, number> = {};
@@ -2276,7 +2369,15 @@ export const hooksSessionEnd: MCPTool = {
handler: async (params: Record<string, unknown>) => {
const saveState = params.saveState !== false;
const shouldStopDaemon = params.stopDaemon !== false;
- const sessionId = `session-${Date.now() - 3600000}`; // Default session (1 hour ago)
+ const session = loadActiveSessionState();
+ if (!session) {
+ throw new Error('No active session state found at .claude-flow/sessions/current.json');
+ }
+ const sessionId = session.id;
+ const endedAt = Date.now();
+ const duration = Math.max(0, endedAt - Date.parse(session.startedAt));
+ const activity = loadSessionActivity(session, endedAt);
+ const summary = buildSessionSummary(activity, duration);
// Stop daemon if enabled
let daemonStopped = false;
@@ -2290,12 +2391,10 @@ export const hooksSessionEnd: MCPTool = {
}
}
- // Read actual counts from stores
+ // Read aggregate store data for the remaining compatibility metrics.
const store = loadMemoryStore();
const allEntries = Object.values(store.entries);
- const taskCount = allEntries.filter(e => e.key.includes('task')).length;
const agentCount = allEntries.filter(e => e.key.includes('agent')).length;
- const patternCount = allEntries.filter(e => e.key.includes('pattern')).length;
const trajectoryCount = activeTrajectories.size;
// Check for pending-insights.jsonl
@@ -2317,9 +2416,9 @@ export const hooksSessionEnd: MCPTool = {
bridge = await import('../memory/memory-bridge.js');
const result = await bridge.bridgeSessionEnd({
sessionId,
- summary: saveState ? 'Session ended with state saved' : 'Session ended',
- tasksCompleted: taskCount,
- patternsLearned: patternCount,
+ summary,
+ tasksCompleted: activity.tasksCompleted,
+ patternsLearned: activity.patternsLearned,
});
if (result) {
sessionPersistence = {
@@ -2342,19 +2441,19 @@ export const hooksSessionEnd: MCPTool = {
return {
sessionId,
- duration: 3600000, // 1 hour in ms
+ duration,
statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
daemon: { stopped: daemonStopped },
sessionPersistence: sessionPersistence || { controller: 'none', persisted: false },
summary: {
- tasksExecuted: taskCount,
- filesModified: 0,
+ tasksExecuted: activity.tasksCompleted,
+ filesModified: activity.editsRecorded,
agentsSpawned: agentCount,
pendingInsights: insightCount,
memoryEntries: allEntries.length,
},
learningUpdates: {
- patternsLearned: patternCount,
+ patternsLearned: activity.patternsLearned,
trajectoriesRecorded: trajectoryCount,
},
};