@claude-flow/cli 3.56.1 → 3.56.3

package/.claude/helpers/helpers.manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest": {
-    "version": "3.56.1",
+    "version": "3.56.3",
     "files": {
       "auto-memory-hook.mjs": "c8d218526a3c34034c2a69de23f507f0eb0f70d59c16426a8edc849e6ac22529",
       "hook-handler.cjs": "34d2aacfb59a73ff94b1467bb57ab9d9c4af89c0e470aadf3bd0d74a503a658d",
@@ -9,6 +9,6 @@
       "router.cjs": "16648b3c0d73b6681ac2d8d13def6a68286c57f5a11004de5b19a0fa088c833d"
     }
   },
-  "signature": "eGhCbWbSEhufQTLyjtRuSNc3JX1kDYCMAbqj/mn4IpYUOX+pi9Xs5lPAo/kVgVolhF1JRspGhzFi3Y8spw0EBw==",
+  "signature": "U1PReRNeRDIa3/64YWz99uxvI1OmVc3d53VBaVg9neZlrSC5LNaCGtMcGyIcrB2bA6jl4SHsHlbDvNcVH38UCw==",
   "algorithm": "ed25519"
 }

package/catalog-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-09T04:37:42.484Z",
-  "gitSha": "58e0ae7e",
+  "generatedAt": "2026-10-09T21:52:00.476Z",
+  "gitSha": "8c60c8c7",
   "catalog": {
     "agents": 176,
     "tools": 423,

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

@@ -2600,8 +2600,12 @@ export const hooksSessionEnd = {
             try {
                 await bridge?.shutdownBridge();
             }
-            catch {
-                // Cleanup is best-effort and must not fail session-end.
+            catch (err) {
+                // Cleanup is best-effort and must not fail session-end, but a failed
+                // AgentDB persist (lock/concurrent writer) is never silent.
+                if (err?.code === 'AGENTDB_LOCK_UNRECOVERABLE') {
+                    process.stderr.write(`[ruflo] warning: ${err.message}\n`);
+                }
             }
         }
         return {

package/dist/src/mcp-tools/task-tools.d.ts

@@ -4,5 +4,10 @@
  * Tool definitions for task management with file persistence.
  */
 import { type MCPTool } from './types.js';
+export declare const TASK_STATUSES: readonly ["pending", "in_progress", "completed", "failed", "cancelled"];
+type TaskStatus = (typeof TASK_STATUSES)[number];
+/** The canonical status for a written one (trimmed, any case, known aliases), or null when it is none of the five. */
+export declare function statusOf(value: unknown): TaskStatus | null;
 export declare const taskTools: MCPTool[];
+export {};
 //# sourceMappingURL=task-tools.d.ts.map

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

@@ -12,6 +12,21 @@ import { validateIdentifier, validateText } from './validate-input.js';
 const STORAGE_DIR = '.claude-flow';
 const TASK_DIR = 'tasks';
 const TASK_FILE = 'store.json';
+export const TASK_STATUSES = ['pending', 'in_progress', 'completed', 'failed', 'cancelled'];
+// Spellings agents write for the same five states (seen in the wild: "complete").
+const STATUS_ALIASES = {
+    complete: 'completed', done: 'completed', canceled: 'cancelled',
+    running: 'in_progress', 'in-progress': 'in_progress', inprogress: 'in_progress',
+};
+/** The canonical status for a written one (trimmed, any case, known aliases), or null when it is none of the five. */
+export function statusOf(value) {
+    if (typeof value !== 'string')
+        return null;
+    const key = value.trim().toLowerCase();
+    if (TASK_STATUSES.includes(key))
+        return key;
+    return Object.hasOwn(STATUS_ALIASES, key) ? STATUS_ALIASES[key] : null;
+}
 function getTaskDir() {
     return join(getProjectCwd(), STORAGE_DIR, TASK_DIR);
 }
@@ -290,7 +305,9 @@ export const taskTools = [
             type: 'object',
             properties: {
                 taskId: { type: 'string', description: 'Task ID' },
-                status: { type: 'string', description: 'New status' },
+                // No schema enum: the HTTP/WebSocket registry validates enums before the handler, which would refuse the aliases there
+                // while stdio accepted them. The handler is the one place that normalises and refuses, for every transport.
+                status: { type: 'string', description: 'New status: pending, in_progress, completed, failed or cancelled' },
                 progress: { type: 'number', description: 'Progress percentage (0-100)' },
                 assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
                 result: { type: 'object', description: 'Result data (e.g. the failure of a failed task)' },
@@ -302,26 +319,52 @@ export const taskTools = [
             const vId = validateIdentifier(input.taskId, 'taskId');
             if (!vId.valid)
                 return { success: false, error: vId.error };
+            // A status outside the five is stored as written otherwise, and every reader that buckets
+            // by status (task_list filters, the console kanban) then miscounts it: "complete" read as pending.
+            const status = input.status === undefined ? undefined : statusOf(input.status);
+            if (status === null) {
+                return { success: false, error: `status must be one of ${TASK_STATUSES.join(', ')}` };
+            }
             const store = loadTaskStore();
             const taskId = input.taskId;
             const task = store.tasks[taskId];
             if (task) {
-                if (input.status) {
-                    const newStatus = input.status;
+                // Worker effects run AFTER the task store is saved, as task_complete does: a failed save must not leave
+                // workers freed and counted against a task that still reads unfinished.
+                let afterSave;
+                if (status !== undefined) {
+                    const newStatus = status;
+                    const wasCompleted = task.status === 'completed';
                     task.status = newStatus;
                     if (newStatus === 'in_progress' && !task.startedAt) {
                         task.startedAt = new Date().toISOString();
                     }
-                    // A failed task frees its workers, as task_complete and task_cancel do;
-                    // otherwise a worker whose run failed stays `busy` forever.
-                    if (newStatus === 'failed') {
+                    // A finished task frees its workers, as task_complete and task_cancel do; otherwise a worker
+                    // whose task was finished through task_update stays `busy` forever, and a later task_complete
+                    // returns early because the status already reads completed.
+                    if (newStatus === 'failed' || newStatus === 'cancelled') {
+                        task.completedAt = new Date().toISOString();
+                        afterSave = () => releaseAgents(task.assignedTo, taskId);
+                    }
+                    if (newStatus === 'completed' && !wasCompleted) {
                         task.completedAt = new Date().toISOString();
-                        releaseAgents(task.assignedTo, taskId);
+                        // Credited only to a worker still holding this task, so complete -> pending -> complete
+                        // (no reassignment in between) never counts the same work twice.
+                        afterSave = () => updateAgents(task.assignedTo, (agent) => {
+                            if (agent.currentTask === taskId) {
+                                agent.status = 'idle';
+                                agent.currentTask = null;
+                                agent.taskCount = (agent.taskCount || 0) + 1;
+                            }
+                        });
                     }
                 }
                 if (typeof input.progress === 'number') {
                     task.progress = Math.min(100, Math.max(0, input.progress));
                 }
+                // Completing is 100% whatever progress the same call carried.
+                if (task.status === 'completed')
+                    task.progress = 100;
                 if (input.assignTo) {
                     task.assignedTo = input.assignTo;
                 }
@@ -329,6 +372,7 @@ export const taskTools = [
                     task.result = input.result;
                 }
                 saveTaskStore(store);
+                afterSave?.();
                 return {
                     success: true,
                     taskId: task.taskId,

package/dist/src/memory/memory-bridge.js

@@ -2087,16 +2087,25 @@ export function shutdownBridge() {
         if (activeOperations > 0)
             await new Promise(resolve => { drained = resolve; });
         await Promise.allSettled([...registryPromises.values()]);
+        // A failed PERSIST (AGENTDB_LOCK_UNRECOVERABLE: live lock or concurrent
+        // writer on a sql.js database) means pending changes were not saved. That
+        // is surfaced after cleanup completes; other close errors stay best-effort.
+        let persistFailure;
         for (const registry of new Set(registryInstances.values())) {
             try {
                 await registry.shutdown();
             }
-            catch { /* best-effort cleanup */ }
+            catch (err) {
+                if (err?.code === 'AGENTDB_LOCK_UNRECOVERABLE')
+                    persistFailure ??= err;
+            }
         }
         registryInstances.clear();
         registryPromises.clear();
         testRegistryOverride = null;
         bridgeFailureReasons.clear();
+        if (persistFailure)
+            throw persistFailure;
     })().finally(() => { shutdownPromise = null; });
     return shutdownPromise;
 }