@claude-flow/cli 3.55.0 → 3.56.1

package/dist/src/mcp-tools/agent-tools.js

@@ -6,6 +6,7 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { readRecordStore } from './record-store.js';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validateAgentSpawn } from './validate-input.js';
 import { executeAgentTask } from './agent-execute-core.js';
@@ -32,17 +33,7 @@ function ensureAgentDir() {
     }
 }
 function loadAgentStore() {
-    try {
-        const path = getAgentPath();
-        if (existsSync(path)) {
-            const data = readFileSync(path, 'utf-8');
-            return JSON.parse(data);
-        }
-    }
-    catch {
-        // Return empty store on error
-    }
-    return { agents: {}, version: '3.0.0' };
+    return readRecordStore(getAgentPath(), 'agents', () => ({ agents: {}, version: '3.0.0' }));
 }
 function saveAgentStore(store) {
     ensureAgentDir();
@@ -247,7 +238,6 @@ export const agentTools = [
             if (!validation.valid) {
                 return { success: false, error: `Input validation failed: ${validation.errors.join('; ')}` };
             }
-            const store = loadAgentStore();
             const agentId = input.agentId || `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             const agentType = input.agentType;
             const config = input.config || {};
@@ -285,6 +275,7 @@ export const agentTools = [
                     : routingResult.provider ? { provider: routingResult.provider } : {}),
                 ...(routingResult.openrouterModel ? { openrouterModel: routingResult.openrouterModel } : {}),
             };
+            const store = loadAgentStore();
             store.agents[agentId] = agent;
             saveAgentStore(store);
             // #2085 — also push to the swarm store's agents array so that
@@ -337,8 +328,13 @@ export const agentTools = [
                         memoryBranch = br.branchPath;
                         agent.memoryBranch = br.branchPath;
                         agent.memoryBase = br.basePath;
-                        store.agents[agentId] = agent;
-                        saveAgentStore(store);
+                        const latest = loadAgentStore();
+                        const current = latest.agents[agentId];
+                        if (current && current.status !== 'terminated') {
+                            current.memoryBranch = br.branchPath;
+                            current.memoryBase = br.basePath;
+                            saveAgentStore(latest);
+                        }
                     }
                     // else: degraded (agenticow missing / kill-switched) — agent stands
                     // without an isolated branch; callers see no memoryBranch field.
@@ -629,7 +625,10 @@ export const agentTools = [
                 };
             }
             if (action === 'scale') {
-                const targetSize = input.targetSize || 5;
+                const targetSize = input.targetSize === undefined ? 5 : input.targetSize;
+                if (typeof targetSize !== 'number' || !Number.isSafeInteger(targetSize) || targetSize < 0) {
+                    return { action, error: 'targetSize must be a non-negative safe integer' };
+                }
                 const agentType = input.agentType || 'worker';
                 const currentSize = agents.filter(a => a.agentType === agentType).length;
                 const delta = targetSize - currentSize;
@@ -663,7 +662,7 @@ export const agentTools = [
                     agentType,
                     previousSize: currentSize,
                     targetSize,
-                    newSize: currentSize + delta,
+                    newSize: currentSize + added.length - removed.length,
                     added,
                     removed,
                 };

package/dist/src/mcp-tools/agentdb-tools.js

@@ -61,6 +61,25 @@ async function getGraphEdgeWriter() {
         graphEdgeWriterMod = await import('../memory/graph-edge-writer.js');
     return graphEdgeWriterMod;
 }
+// #2889 — a null graph_edges DB handle can mean several unrelated things
+// (missing native module, permissions, genuine corruption, or an RFE1
+// encrypted-at-rest store). Recommending `memory init` for the encrypted
+// case is actively harmful — it creates a fresh EMPTY store instead of
+// using the existing encrypted data — so distinguish it before choosing
+// a hint.
+async function bridgeUnavailableResult() {
+    const { isBridgeDbEncryptedAtRest } = await getGraphEdgeWriter();
+    if (isBridgeDbEncryptedAtRest()) {
+        return {
+            error: 'graph_edges DB is encrypted at rest (RFE1) — the native bridge cannot open it directly.',
+            hint: 'Your existing data is intact; this is a known limitation, not corruption. Do NOT run `memory init` — see https://github.com/ruvnet/ruflo/issues/2889.',
+        };
+    }
+    return {
+        error: 'graph_edges DB unavailable (sql.js could not load)',
+        hint: 'Check Node version + try `ruflo memory init` to initialize manually.',
+    };
+}
 let memInitMod = null;
 async function getMemInit() {
     if (!memInitMod)
@@ -1152,7 +1171,7 @@ export const agentdbGraphQuery = {
                     // fresh environments work without a pre-existing memory init.
                     const db = await getBridgeDb(undefined, { createIfMissing: true });
                     if (!db)
-                        return { success: false, error: 'graph_edges DB unavailable (sql.js could not load)', hint: 'Check Node version + try `ruflo memory init` to initialize manually.', mode, nodeId };
+                        return { success: false, ...(await bridgeUnavailableResult()), mode, nodeId };
                     // Load all rows with embedding_ref and score by cosine.
                     // better-sqlite3 API — `db.exec(sql, params)` (sql.js) silently
                     // throws "datatype mismatch" because exec ignores params, so `?`
@@ -1194,7 +1213,7 @@ export const agentdbGraphQuery = {
                     // fresh environments work without a pre-existing memory init.
                     const db = await getBridgeDb(undefined, { createIfMissing: true });
                     if (!db)
-                        return { success: false, error: 'graph_edges DB unavailable (sql.js could not load)', hint: 'Check Node version + try `ruflo memory init` to initialize manually.', mode, nodeId };
+                        return { success: false, ...(await bridgeUnavailableResult()), mode, nodeId };
                     // better-sqlite3 API — see semantic-mode comment above.
                     const edges = db.prepare(`SELECT source_id, target_id, weight FROM graph_edges LIMIT ?`).raw().all(budget.maxNodesVisited);
                     if (edges.length === 0) {
@@ -1380,7 +1399,7 @@ export const agentdbGraphPathfinder = {
             // #2246 fix: lazy-create memory.db on first pathfinder call.
             const db = await getBridgeDb(undefined, { createIfMissing: true });
             if (!db)
-                return { success: false, error: 'graph_edges DB unavailable (sql.js could not load)', hint: 'Check Node version + try `ruflo memory init` to initialize manually.', seedNodeId };
+                return { success: false, ...(await bridgeUnavailableResult()), seedNodeId };
             const colsSql = algorithm === 'witness-chain-divergence'
                 ? 'source_id, target_id, weight, last_reinforced, witness_id'
                 : algorithm === 'temporal-centrality'

package/dist/src/mcp-tools/claims-tools.js

@@ -6,9 +6,10 @@
  *
  * @module @claude-flow/cli/mcp-tools/claims
  */
+import { readClaimsStore } from '../services/claims-store.js';
 import { validateIdentifier, validateText } from './validate-input.js';
 // File-based persistence
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 const CLAIMS_DIR = '.claude-flow/claims';
 const CLAIMS_FILE = 'claims.json';
@@ -22,16 +23,7 @@ function ensureClaimsDir() {
     }
 }
 function loadClaims() {
-    try {
-        const path = getClaimsPath();
-        if (existsSync(path)) {
-            return JSON.parse(readFileSync(path, 'utf-8'));
-        }
-    }
-    catch {
-        // Return empty store on error
-    }
-    return { claims: {}, stealable: {}, contests: {} };
+    return readClaimsStore(getClaimsPath());
 }
 function saveClaims(store) {
     ensureClaimsDir();

package/dist/src/mcp-tools/config-tools.js

@@ -35,12 +35,110 @@ function ensureConfigDir() {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
 }
+// Plain CLI files and legacy MCP envelopes share the same path. Keep the
+// original plain document so MCP writes remain readable by the CLI.
+const plainDocuments = new WeakMap();
+const STORE_METADATA = new Set(['scopes', 'version', 'updatedAt']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function flattenValues(document) {
+    const values = {};
+    function visit(value, key) {
+        if (isRecord(value) && Object.keys(value).length > 0) {
+            for (const [child, entry] of Object.entries(value))
+                visit(entry, `${key}.${child}`);
+        }
+        else {
+            Object.defineProperty(values, key, { value, enumerable: true, configurable: true, writable: true });
+        }
+    }
+    for (const [key, value] of Object.entries(document)) {
+        if (!STORE_METADATA.has(key))
+            visit(value, key);
+    }
+    // CLI reads literal dotted keys before traversing nested objects.
+    for (const [key, value] of Object.entries(document)) {
+        if (key.includes('.'))
+            Object.defineProperty(values, key, { value, enumerable: true, configurable: true, writable: true });
+    }
+    return values;
+}
+function readDefaultValue(store, key) {
+    const document = plainDocuments.get(store);
+    if (!document)
+        return store.values[key];
+    return Object.hasOwn(document, key) ? document[key] : getNestedValue(document, key);
+}
+function writeDefaultValue(store, key, value) {
+    const document = plainDocuments.get(store);
+    if (!document) {
+        store.values[key] = value;
+        return;
+    }
+    // Keep existing literal dotted keys; otherwise use the CLI's nested shape.
+    if (Object.hasOwn(document, key)) {
+        // Reuse the same segment validation as nested writes.
+        setNestedValue({}, key, value);
+        document[key] = value;
+    }
+    else {
+        setNestedValue(document, key, value);
+    }
+    store.values = flattenValues(document);
+}
+function deleteDefaultValue(store, key) {
+    const document = plainDocuments.get(store);
+    if (!document)
+        return Object.hasOwn(store.values, key) && delete store.values[key];
+    let target = document;
+    let leaf = key;
+    if (!Object.hasOwn(document, key)) {
+        const parts = key.split('.');
+        leaf = parts.pop();
+        for (const part of parts) {
+            if (!Object.hasOwn(target, part) || !isRecord(target[part]))
+                return false;
+            target = target[part];
+        }
+    }
+    const deleted = Object.hasOwn(target, leaf) && delete target[leaf];
+    store.values = flattenValues(document);
+    return deleted;
+}
+function replaceDefaultValues(store, values) {
+    const document = plainDocuments.get(store);
+    if (!document) {
+        store.values = values;
+        return;
+    }
+    for (const key of Object.keys(document)) {
+        if (!STORE_METADATA.has(key))
+            delete document[key];
+    }
+    for (const [key, value] of Object.entries(values))
+        writeDefaultValue(store, key, value);
+}
 function loadConfigStore() {
     try {
         const path = getConfigPath();
         if (existsSync(path)) {
             const data = readFileSync(path, 'utf-8');
-            return JSON.parse(data);
+            const document = JSON.parse(data);
+            const isEnvelope = isRecord(document) && isRecord(document.values)
+                && isRecord(document.scopes) && typeof document.version === 'string'
+                && typeof document.updatedAt === 'string';
+            if (isRecord(document) && !isEnvelope) {
+                const store = {
+                    values: flattenValues(document),
+                    scopes: isRecord(document.scopes) ? document.scopes : {},
+                    version: typeof document.version === 'string' ? document.version : '3.0.0',
+                    updatedAt: typeof document.updatedAt === 'string' ? document.updatedAt : '',
+                };
+                plainDocuments.set(store, document);
+                return store;
+            }
+            return document;
         }
     }
     catch {
@@ -56,13 +154,20 @@ function loadConfigStore() {
 function saveConfigStore(store) {
     ensureConfigDir();
     store.updatedAt = new Date().toISOString();
-    writeFileSync(getConfigPath(), JSON.stringify(store, null, 2), 'utf-8');
+    const document = plainDocuments.get(store);
+    if (document) {
+        document.updatedAt = store.updatedAt;
+        if (Object.keys(store.scopes).length > 0 || Object.hasOwn(document, 'scopes')) {
+            document.scopes = store.scopes;
+        }
+    }
+    writeFileSync(getConfigPath(), JSON.stringify(document ?? store, null, 2), 'utf-8');
 }
 function getNestedValue(obj, key) {
     const parts = key.split('.');
     let current = obj;
     for (const part of parts) {
-        if (current && typeof current === 'object' && part in current) {
+        if (current && typeof current === 'object' && Object.hasOwn(current, part)) {
             current = current[part];
         }
         else {
@@ -95,7 +200,7 @@ function setNestedValue(obj, key, value) {
     let current = obj;
     for (let i = 0; i < parts.length - 1; i++) {
         const part = parts[i];
-        if (!(part in current) || typeof current[part] !== 'object') {
+        if (!Object.hasOwn(current, part) || current[part] === null || typeof current[part] !== 'object') {
             current[part] = {};
         }
         current = current[part];
@@ -134,7 +239,7 @@ export const configTools = [
                 value = store.scopes[scope][key];
             }
             if (value === undefined) {
-                value = store.values[key];
+                value = readDefaultValue(store, key);
             }
             if (value === undefined) {
                 value = DEFAULT_CONFIG[key];
@@ -144,7 +249,7 @@ export const configTools = [
                 value,
                 scope,
                 exists: value !== undefined,
-                source: value !== undefined ? (store.values[key] !== undefined ? 'stored' : 'default') : 'none',
+                source: value !== undefined ? (readDefaultValue(store, key) !== undefined ? 'stored' : 'default') : 'none',
             };
         },
     },
@@ -175,9 +280,9 @@ export const configTools = [
             const key = input.key;
             const value = input.value;
             const scope = input.scope || 'default';
-            const previousValue = store.values[key];
+            const previousValue = readDefaultValue(store, key);
             if (scope === 'default') {
-                store.values[key] = value;
+                writeDefaultValue(store, key, value);
             }
             else {
                 if (!store.scopes[scope]) {
@@ -289,8 +394,7 @@ export const configTools = [
             if (key) {
                 // Reset specific key
                 if (scope === 'default') {
-                    if (key in store.values) {
-                        delete store.values[key];
+                    if (deleteDefaultValue(store, key)) {
                         resetKeys.push(key);
                     }
                 }
@@ -303,7 +407,7 @@ export const configTools = [
                 // Reset all keys in scope
                 if (scope === 'default') {
                     resetKeys = Object.keys(store.values);
-                    store.values = { ...DEFAULT_CONFIG };
+                    replaceDefaultValues(store, { ...DEFAULT_CONFIG });
                 }
                 else if (store.scopes[scope]) {
                     resetKeys = Object.keys(store.scopes[scope]);
@@ -385,10 +489,11 @@ export const configTools = [
             const importedKeys = Object.keys(config);
             if (scope === 'default') {
                 if (merge) {
-                    Object.assign(store.values, config);
+                    for (const [key, value] of Object.entries(config))
+                        writeDefaultValue(store, key, value);
                 }
                 else {
-                    store.values = { ...DEFAULT_CONFIG, ...config };
+                    replaceDefaultValues(store, { ...DEFAULT_CONFIG, ...config });
                 }
             }
             else {

package/dist/src/mcp-tools/hooks-tools.js

@@ -1154,14 +1154,59 @@ export const hooksRoute = {
             catch {
                 // AgentDB router not available — fall through to local routing
             }
+            // Trajectory learning persists SONA outcomes separately from the local
+            // semantic index. Only consume an eligible learned pattern here; native,
+            // Q-learning and keyword suggestions retain their existing routing paths.
+            try {
+                const sonaStart = performance.now();
+                const sona = await getSONAOptimizer();
+                const suggestion = await sona?.getRoutingSuggestion(task);
+                const { isSupportedSonaAgent } = await import('../memory/sona-optimizer.js');
+                if (suggestion?.source === 'sona-pattern'
+                    && Number.isFinite(suggestion.confidence)
+                    && suggestion.confidence >= 0.6 && suggestion.confidence <= 1
+                    && isSupportedSonaAgent(suggestion.agent)) {
+                    const confidence = Math.round(suggestion.confidence * 100) / 100;
+                    const complexity = task.length > 200 ? 'high' : task.length < 50 ? 'low' : 'medium';
+                    return {
+                        task,
+                        routing: { method: 'sona-pattern', backend: 'SONA persisted keyword patterns', latencyMs: performance.now() - sonaStart, throughput: 'N/A' },
+                        matched: true,
+                        matchedPattern: 'sona-pattern',
+                        semanticMatches: [],
+                        primaryAgent: {
+                            type: suggestion.agent,
+                            confidence,
+                            reason: `Persisted SONA outcome pattern (${Math.round(suggestion.confidence * 100)}% confidence)`,
+                        },
+                        alternativeAgents: suggestion.alternatives
+                            .filter(alternative => isSupportedSonaAgent(alternative.agent) && Number.isFinite(alternative.score))
+                            .map(alternative => ({
+                            type: alternative.agent,
+                            confidence: Math.round(alternative.score * 100) / 100,
+                            reason: 'Alternative from persisted SONA patterns',
+                        })),
+                        estimatedMetrics: {
+                            successProbability: confidence,
+                            estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
+                            complexity,
+                        },
+                        swarmRecommendation: null,
+                        learning: { source: suggestion.source, matchedKeywords: suggestion.matchedKeywords },
+                    };
+                }
+            }
+            catch {
+                // Optional SONA state unavailable — preserve the existing local route.
+            }
         }
         return routeTaskLocal(task, context, useSemanticRouter);
     }),
 };
 /**
  * hooks_route's local routing (semantic index + keyword fallback), run after the
- * AgentDB pre-route. Shared with {@link routeTaskForBench} so the benchmark
- * measures exactly the path hooks_route takes. (Body kept at its original
+ * AgentDB and eligible SONA pre-routes. Shared with {@link routeTaskForBench}
+ * so the benchmark measures this local path. (Body kept at its original
  * indentation to keep this refactor's diff small.)
  */
 async function routeTaskLocal(task, context, useSemanticRouter, embedderOverride) {

package/dist/src/mcp-tools/memory-tools.js

@@ -1500,7 +1500,21 @@ export const memoryTools = [
             // entry body. Without this, `value` is always null because listEntries
             // strips content by default (callers pay for the JSON parse only when
             // they need it).
-            const all = await listEntries({ limit: 100000, namespace, includeContent: true });
+            // A successful export must cover the whole reported store. Read all
+            // pages before touching an existing snapshot, including on read failure.
+            const entries = [];
+            let total;
+            do {
+                const page = await listEntries({ limit: 10000, offset: entries.length, namespace, includeContent: true });
+                if (!page.success)
+                    return { error: page.error || 'Could not read memory for export' };
+                total ??= page.total;
+                if (page.entries.length === 0 && entries.length < total) {
+                    return { error: `Incomplete memory export: read ${entries.length} of ${total} entries` };
+                }
+                entries.push(...page.entries);
+            } while (entries.length < total);
+            const all = { entries };
             const payload = {
                 schema: 'ruflo-memory-export/v1',
                 exportedAt: new Date().toISOString(),
@@ -1595,6 +1609,8 @@ export const memoryTools = [
             }
             let imported = 0;
             let skipped = 0;
+            let failed = 0;
+            const errors = [];
             for (const e of entries) {
                 if (!e || typeof e.key !== 'string') {
                     skipped++;
@@ -1603,19 +1619,22 @@ export const memoryTools = [
                 const value = typeof e.value === 'string' ? e.value : JSON.stringify(e.value ?? null);
                 try {
                     const result = await storeEntry({ key: e.key, value, namespace: nsOverride ?? e.namespace ?? 'default', upsert: input.merge !== false, dbPath });
-                    if (result.success) {
-                        imported++;
-                        if (result.embedding)
-                            vectors++;
-                    }
-                    else
-                        skipped++;
+                    if (!result.success)
+                        throw new Error(result.error || 'Memory write was rejected');
+                    imported++;
+                    if (result.embedding)
+                        vectors++;
                 }
-                catch {
-                    skipped++;
+                catch (error) {
+                    failed++;
+                    if (errors.length < 10)
+                        errors.push(`${e.key}: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             return {
+                success: failed === 0,
+                error: failed > 0 ? `${failed} memory write(s) failed: ${errors.join('; ')}` : undefined,
+                failed,
                 inputPath,
                 imported: { entries: imported, vectors, patterns: 0 },
                 skipped,

package/dist/src/mcp-tools/record-store.d.ts

@@ -0,0 +1,3 @@
+/** Only an absent store is empty. Failed reads must never authorize replacement. */
+export declare function readRecordStore<T>(path: string, collection: string, empty: () => T): T;
+//# sourceMappingURL=record-store.d.ts.map

package/dist/src/mcp-tools/record-store.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+/** Only an absent store is empty. Failed reads must never authorize replacement. */
+export function readRecordStore(path, collection, empty) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return empty();
+        throw error;
+    }
+    const store = JSON.parse(text);
+    const records = store?.[collection];
+    if (!store || typeof store !== 'object' || Array.isArray(store)
+        || !records || typeof records !== 'object' || Array.isArray(records)) {
+        throw new Error(`Invalid ${collection} store at ${path}; existing data was preserved`);
+    }
+    return store;
+}
+//# sourceMappingURL=record-store.js.map

package/dist/src/mcp-tools/session-tools.js

@@ -10,6 +10,33 @@ import { join } from 'node:path';
 import { getProjectCwd } from './types.js';
 import { mkdirRestricted, readFileMaybeEncrypted, writeFileRestricted, } from '../fs-secure.js';
 import { validateIdentifier, validateText } from './validate-input.js';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+// Imported snapshots become live stores on restore. Validate their containers
+// before registering them, while allowing older metadata-only snapshots.
+function validateImportedSession(value) {
+    if (!isRecord(value) || (typeof value.name !== 'string' && !isSessionRecordLike(value))) {
+        return 'Invalid session: Not a session record; expected a named snapshot or snapshot data';
+    }
+    if (value.name !== undefined && typeof value.name !== 'string') {
+        return 'Invalid session: name must be a string';
+    }
+    if (value.data === undefined)
+        return undefined;
+    if (!isRecord(value.data))
+        return 'Invalid session: data must be an object';
+    for (const [component, collection] of [['tasks', 'tasks'], ['agents', 'agents'], ['memory', 'entries']]) {
+        const store = value.data[component];
+        if (store === undefined)
+            continue;
+        if (!isRecord(store) || !isRecord(store[collection]) ||
+            Object.values(store[collection]).some(record => !isRecord(record))) {
+            return `Invalid session: data.${component}.${collection} must be a record map`;
+        }
+    }
+    return undefined;
+}
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const SESSION_DIR = 'sessions';
@@ -306,9 +333,9 @@ export const sessionTools = [
             properties: {
                 name: { type: 'string', description: 'Session name' },
                 description: { type: 'string', description: 'Session description' },
-                includeMemory: { type: 'boolean', description: 'Include memory in session' },
-                includeTasks: { type: 'boolean', description: 'Include tasks in session' },
-                includeAgents: { type: 'boolean', description: 'Include agents in session' },
+                includeMemory: { type: 'boolean', default: true, description: 'Include memory in session' },
+                includeTasks: { type: 'boolean', default: true, description: 'Include tasks in session' },
+                includeAgents: { type: 'boolean', default: true, description: 'Include agents in session' },
             },
             required: ['name'],
         },
@@ -325,9 +352,9 @@ export const sessionTools = [
             const sessionId = `session-${Date.now()}-${randomUUID().slice(0, 8)}`;
             // Load related data based on options
             const { data, memoryCapture } = await loadRelatedStores({
-                includeMemory: input.includeMemory,
-                includeTasks: input.includeTasks,
-                includeAgents: input.includeAgents,
+                includeMemory: input.includeMemory !== false,
+                includeTasks: input.includeTasks !== false,
+                includeAgents: input.includeAgents !== false,
             });
             // Calculate stats
             const stats = {
@@ -692,19 +719,26 @@ export const sessionTools = [
                     return { error: `Invalid session JSON: ${e.message}` };
                 }
             }
-            if (!isSessionRecordLike(parsed)) {
-                return { error: 'Not a session record: expected an object produced by session export' };
-            }
+            const validationError = validateImportedSession(parsed);
+            if (validationError)
+                return { error: validationError };
+            const record = parsed;
             const newId = `session-${Date.now()}-${randomUUID().slice(0, 8)}`;
-            const stats = { tasks: 0, agents: 0, memoryEntries: 0, totalSize: 0, ...(parsed.stats || {}) };
+            const stats = {
+                tasks: Object.keys(record.data?.tasks?.tasks || {}).length,
+                agents: Object.keys(record.data?.agents?.agents || {}).length,
+                memoryEntries: countMemoryEntries(record.data?.memory),
+                totalSize: 0,
+            };
             const session = {
                 sessionId: newId,
-                name: input.name ? String(input.name) : (parsed.name || 'imported-session'),
-                description: parsed.description,
+                name: input.name ? String(input.name) : (record.name || 'imported-session'),
+                description: record.description,
                 savedAt: new Date().toISOString(),
                 stats,
-                data: parsed.data,
+                data: record.data,
             };
+            session.stats.totalSize = Buffer.byteLength(JSON.stringify(session), 'utf-8');
             saveSession(session);
             let activated = false;
             if (input.activate === true) {

package/dist/src/mcp-tools/task-tools.js

@@ -5,6 +5,7 @@
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { readRecordStore } from './record-store.js';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText } from './validate-input.js';
 // Storage paths
@@ -24,17 +25,7 @@ function ensureTaskDir() {
     }
 }
 function loadTaskStore() {
-    try {
-        const path = getTaskPath();
-        if (existsSync(path)) {
-            const data = readFileSync(path, 'utf-8');
-            return JSON.parse(data);
-        }
-    }
-    catch {
-        // Return empty store on error
-    }
-    return { tasks: {}, version: '3.0.0' };
+    return readRecordStore(getTaskPath(), 'tasks', () => ({ tasks: {}, version: '3.0.0' }));
 }
 function saveTaskStore(store) {
     ensureTaskDir();
@@ -378,6 +369,9 @@ export const taskTools = [
                 return { taskId, error: 'Task not found' };
             }
             const previouslyAssigned = [...task.assignedTo];
+            // Load agent store to sync worker state
+            const agentStorePath = join(getProjectCwd(), STORAGE_DIR, 'agents', 'store.json');
+            readRecordStore(agentStorePath, 'agents', () => ({ agents: {} }));
             if (input.unassign) {
                 // Revert previously assigned agents to idle
                 releaseAgents(previouslyAssigned, taskId);