@claude-flow/cli 3.71.2 → 3.71.3

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

@@ -985,12 +985,12 @@ export const agentdbBatch = {
 // ===== agentdb_context_synthesize — Synthesize context from memories =====
 export const agentdbContextSynthesize = {
     name: 'agentdb_context-synthesize',
-    description: 'Synthesize context from stored memories for a given query Use when generic memory_* tools are wrong because you need AgentDB-specific controllers (HNSW vector search, hierarchical tiers, causal-graph links, pattern store/recall, RaBitQ quantization). For simple key-value persistence, memory_store/memory_retrieve are simpler. For unrelated file work, native Read/Write are fine.',
+    description: 'Summarize validated task episodes (task, reward, success, critique) that match a query: observed success rate, reward and critique-derived patterns. Ordinary documents, research notes and graph entities are not episodes, so for them it answers no-memories or no-eligible-episodes; read those with memory_search or memory_retrieve instead. Use when generic memory_* tools are wrong because you need AgentDB-specific controllers (HNSW vector search, hierarchical tiers, causal-graph links, pattern store/recall, RaBitQ quantization). For simple key-value persistence, memory_store/memory_retrieve are simpler. For unrelated file work, native Read/Write are fine.',
     inputSchema: {
         type: 'object',
         properties: {
-            query: { type: 'string', description: 'Query to synthesize context for' },
-            maxEntries: { type: 'number', description: 'Maximum entries to include (default: 10)' },
+            query: { type: 'string', description: 'Task to find matching validated episodes for' },
+            maxEntries: { type: 'number', description: 'Maximum episodes to include (default: 10)' },
         },
         required: ['query'],
     },

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

@@ -36,6 +36,10 @@ function formatClaimant(claimant) {
         ? `human:${claimant.userId}:${claimant.name}`
         : `agent:${claimant.agentId}:${claimant.agentType}`;
 }
+/** An agent's claim that is still work in hand (not completed). */
+function isOpenAgentClaim(claim) {
+    return claim.claimant.type === 'agent' && claim.status !== 'completed';
+}
 function parseClaimant(str) {
     const parts = str.split(':');
     if (parts[0] === 'human' && parts.length >= 3) {
@@ -274,6 +278,10 @@ export const claimsTools = [
             if (progress !== undefined) {
                 claim.progress = Math.min(100, Math.max(0, progress));
             }
+            // A claim being handed to a named claimant is no longer up for grabs:
+            // drop it from the list claims_stealable and claims_steal read, so it
+            // cannot be stolen while the handoff is pending or after it is accepted.
+            delete store.stealable[issueId];
             store.claims[issueId] = claim;
             saveClaims(store);
             return {
@@ -678,12 +686,12 @@ export const claimsTools = [
                     return { success: false, error: v.error };
             }
             const store = loadClaims();
-            const claims = Object.values(store.claims);
+            // A completed claim stays in the store but is no longer work in hand,
+            // so it does not count toward an agent's load.
+            const openAgentClaims = Object.values(store.claims).filter(isOpenAgentClaim);
             // Group claims by agent
             const agentLoads = new Map();
-            for (const claim of claims) {
-                if (claim.claimant.type !== 'agent')
-                    continue;
+            for (const claim of openAgentClaims) {
                 const key = claim.claimant.agentId;
                 if (!agentLoads.has(key)) {
                     agentLoads.set(key, {
@@ -723,7 +731,7 @@ export const claimsTools = [
                 success: true,
                 loads: result,
                 totalAgents: result.length,
-                totalClaims: claims.filter(c => c.claimant.type === 'agent').length,
+                totalClaims: openAgentClaims.length,
                 avgUtilization: result.length > 0
                     ? result.reduce((sum, l) => sum + l.utilization, 0) / result.length
                     : 0,
@@ -802,12 +810,11 @@ export const claimsTools = [
             const dryRun = input.dryRun !== false;
             const targetUtilization = input.targetUtilization || 0.7;
             const store = loadClaims();
-            const claims = Object.values(store.claims);
+            // Completed claims are not load, as in claims_load.
+            const openAgentClaims = Object.values(store.claims).filter(isOpenAgentClaim);
             // Group by agent
             const agentLoads = new Map();
-            for (const claim of claims) {
-                if (claim.claimant.type !== 'agent')
-                    continue;
+            for (const claim of openAgentClaims) {
                 const key = claim.claimant.agentId;
                 if (!agentLoads.has(key)) {
                     agentLoads.set(key, { agentId: key, agentType: claim.claimant.agentType, claims: [] });

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

@@ -4096,11 +4096,21 @@ export const hooksIntelligenceLearn = {
     inputSchema: {
         type: 'object',
         properties: {
-            trajectoryIds: { type: 'array', items: { type: 'string' }, description: 'Specific trajectories to learn from' },
+            trajectoryIds: { type: 'array', items: { type: 'string' }, description: 'Not supported: a learning cycle always covers every recorded trajectory. Supplying this returns an error and runs nothing, rather than learning from more than was asked (#4693).' },
             consolidate: { type: 'boolean', description: 'Run EWC++ consolidation' },
         },
     },
     handler: async (params) => {
+        // #4693: distillLearning() and the background pass have no way to select
+        // trajectories, so a request scoped to some must not trigger learning over all.
+        // Refuse it before anything is imported or mutated; omitting the field is unchanged.
+        if (params.trajectoryIds !== undefined) {
+            return {
+                success: false,
+                learned: false,
+                error: 'hooks_intelligence_learn: trajectoryIds is not supported; a learning cycle always covers every recorded trajectory. Omit trajectoryIds to run it.',
+            };
+        }
         const consolidate = params.consolidate !== false;
         const startTime = Date.now();
         // AUDIT FIX #5: actually TRIGGER a learning/consolidation cycle instead of

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

@@ -117,6 +117,10 @@ export const taskTools = [
             const vDesc = validateText(input.description, 'description');
             if (!vDesc.valid)
                 return { success: false, error: vDesc.error };
+            if (input.assignTo !== undefined && (!Array.isArray(input.assignTo)
+                || !input.assignTo.every(id => validateIdentifier(id, 'assignTo').valid))) {
+                return { success: false, error: 'assignTo must be an array of agent ids' };
+            }
             const store = loadTaskStore();
             const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             const task = {
@@ -134,6 +138,13 @@ export const taskTools = [
             };
             store.tasks[taskId] = task;
             saveTaskStore(store);
+            // Assigning at creation must mark the workers busy, as task_assign and task_update do;
+            // otherwise they read idle while holding the task, and task_complete or task_cancel,
+            // which only release a worker whose currentTask is this task, never free them either.
+            updateAgents(task.assignedTo, (agent) => {
+                agent.status = 'busy';
+                agent.currentTask = taskId;
+            });
             return {
                 taskId,
                 type: task.type,

package/dist/src/missions/schemas.d.ts

@@ -77,15 +77,15 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     plan: {
         digest: string;
         revision: number;
         taskGraphRef: string;
     };
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     objective: string;
     missionId: string;
     tenantId: string;
@@ -103,15 +103,15 @@ export declare const missionRecordSchema: z.ZodObject<{
     updatedAt: string;
     schemaVersion: 1;
     state: "completed" | "cancelled" | "failed" | "blocked" | "running" | "paused" | "queued" | "draft" | "planned" | "awaitingAuthorization" | "pauseRequested" | "verifying" | "cancelRequested";
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     plan: {
         digest: string;
         revision: number;
         taskGraphRef: string;
     };
+    acceptance: {
+        revision: number;
+        criteriaDigest: string;
+    };
     objective: string;
     missionId: string;
     tenantId: string;
@@ -580,7 +580,6 @@ export declare const planInputSchema: z.ZodObject<{
         } | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
-    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -617,10 +616,10 @@ export declare const planInputSchema: z.ZodObject<{
             baseline?: string | undefined;
         }[];
     };
+    requestId: string;
     missionId: string;
     expectedRevision: number;
 }, {
-    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -657,6 +656,7 @@ export declare const planInputSchema: z.ZodObject<{
             capabilities?: string[] | undefined;
         } | undefined;
     };
+    requestId: string;
     missionId: string;
     expectedRevision: number;
 }>;

package/dist/src/mods/headless-plugins.d.ts

@@ -14,10 +14,20 @@
  *
  * Profile override: `RUFLO_HEADLESS_PLUGINS` is a comma list of plugin names;
  * `none` (or an empty value) turns plugin loading off.
+ *
+ * Permission mode: Claude Code 2.1.302 starts a `claude -p` with no
+ * permission mode in `manual` mode on third-party providers, with telemetry
+ * off, or on a fresh install. A headless worker has nobody to answer a prompt,
+ * so a print-mode argv without its own `--permission-mode` or
+ * `--dangerously-skip-permissions` gets `--permission-mode auto` — the mode
+ * first-party installs already started in. `RUFLO_HEADLESS_PERMISSION_MODE`
+ * picks another mode; `none` (or an empty value) passes no flag.
  */
 import { type ResolveOptions, type PluginPaths } from './plugin-paths.js';
 export declare const DEFAULT_WORKER_PLUGINS: readonly string[];
 export declare const PROFILE_ENV = "RUFLO_HEADLESS_PLUGINS";
+export declare const PERMISSION_MODE_ENV = "RUFLO_HEADLESS_PERMISSION_MODE";
+export declare const DEFAULT_HEADLESS_PERMISSION_MODE = "auto";
 export interface HeadlessPluginOptions extends ResolveOptions {
     /** Plugin names to load; defaults to the env profile, else DEFAULT_WORKER_PLUGINS. */
     profile?: readonly string[];
@@ -40,5 +50,11 @@ export declare function resetHeadlessPluginWarnings(): void;
 export declare function workerProfile(env?: NodeJS.ProcessEnv, explicit?: readonly string[]): string[];
 /** Every `--plugin-dir` value already in argv (both `--plugin-dir x` and `--plugin-dir=x`). */
 export declare function existingPluginDirs(argv: readonly string[]): string[];
+/**
+ * The `--permission-mode` args to append to a headless argv: none when the
+ * argv is not print mode or already sets a mode, else the env choice
+ * (default `auto`). An unknown mode is ignored with the default used instead.
+ */
+export declare function headlessPermissionArgs(argv: readonly string[], env?: NodeJS.ProcessEnv): string[];
 export declare function withHeadlessPlugins<E extends Record<string, string | undefined>>(argv: readonly string[], env: E, opts?: HeadlessPluginOptions): HeadlessPluginResult<E>;
 //# sourceMappingURL=headless-plugins.d.ts.map

package/dist/src/mods/headless-plugins.js

@@ -14,6 +14,14 @@
  *
  * Profile override: `RUFLO_HEADLESS_PLUGINS` is a comma list of plugin names;
  * `none` (or an empty value) turns plugin loading off.
+ *
+ * Permission mode: Claude Code 2.1.302 starts a `claude -p` with no
+ * permission mode in `manual` mode on third-party providers, with telemetry
+ * off, or on a fresh install. A headless worker has nobody to answer a prompt,
+ * so a print-mode argv without its own `--permission-mode` or
+ * `--dangerously-skip-permissions` gets `--permission-mode auto` — the mode
+ * first-party installs already started in. `RUFLO_HEADLESS_PERMISSION_MODE`
+ * picks another mode; `none` (or an empty value) passes no flag.
  */
 import { realpathSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
@@ -21,6 +29,9 @@ import { ENABLE_ENV } from './install.js';
 import { resolvePluginPaths } from './plugin-paths.js';
 export const DEFAULT_WORKER_PLUGINS = ['ruflo-mods'];
 export const PROFILE_ENV = 'RUFLO_HEADLESS_PLUGINS';
+export const PERMISSION_MODE_ENV = 'RUFLO_HEADLESS_PERMISSION_MODE';
+export const DEFAULT_HEADLESS_PERMISSION_MODE = 'auto';
+const PERMISSION_MODES = new Set(['acceptEdits', 'auto', 'bypassPermissions', 'manual', 'default', 'dontAsk', 'plan']);
 const warned = new Set();
 /** For tests: forget which missing plugins were already logged. */
 export function resetHeadlessPluginWarnings() {
@@ -56,9 +67,27 @@ export function existingPluginDirs(argv) {
     }
     return dirs;
 }
+/**
+ * The `--permission-mode` args to append to a headless argv: none when the
+ * argv is not print mode or already sets a mode, else the env choice
+ * (default `auto`). An unknown mode is ignored with the default used instead.
+ */
+export function headlessPermissionArgs(argv, env = process.env) {
+    const isPrint = argv.some((a) => a === '-p' || a === '--print');
+    if (!isPrint)
+        return [];
+    const hasMode = argv.some((a) => a === '--permission-mode' || a.startsWith('--permission-mode=') || a === '--dangerously-skip-permissions');
+    if (hasMode)
+        return [];
+    const raw = env[PERMISSION_MODE_ENV];
+    if (raw !== undefined && (raw.trim() === '' || raw.trim().toLowerCase() === 'none'))
+        return [];
+    const mode = raw !== undefined && PERMISSION_MODES.has(raw.trim()) ? raw.trim() : DEFAULT_HEADLESS_PERMISSION_MODE;
+    return ['--permission-mode', mode];
+}
 export function withHeadlessPlugins(argv, env, opts = {}) {
     const profile = workerProfile(opts.env ?? env, opts.profile);
-    const outArgv = [...argv];
+    const outArgv = [...argv, ...headlessPermissionArgs(argv, opts.env ?? env)];
     const outEnv = { ...env };
     if (profile.length === 0)
         return { argv: outArgv, env: outEnv, added: [], missing: [] };

package/dist/src/services/daemon-autostart.d.ts

@@ -1,5 +1,29 @@
 /** True if a live daemon already holds the project's pidfile. */
 export declare function isDaemonAlive(projectRoot: string): boolean;
+/**
+ * #4654: an explicit `daemon stop` is an opt-out that must survive the next
+ * hook. Every ruflo-core plugin hook (PreToolUse/PostToolUse, PreCompact, Stop)
+ * runs the CLI, and the CLI auto-starts a daemon whenever none is alive, so a
+ * stopped daemon came back within minutes. `daemon stop` now writes this
+ * marker, auto-start honours it, and only an explicit `daemon start` clears it.
+ */
+export declare const DAEMON_STOP_MARKER = "daemon.stopped";
+/**
+ * Set on the daemon that auto-start spawns, so that spawned `daemon start` does
+ * not clear a stop marker written after auto-start checked it (a `daemon stop`
+ * racing a hook). Only a user-driven start clears the marker.
+ */
+export declare const AUTOSTART_ENV = "RUFLO_DAEMON_AUTOSTARTED";
+/** True if the user explicitly stopped the daemon for this project (#4654). */
+export declare function isDaemonStopMarked(projectRoot: string): boolean;
+/**
+ * Record an explicit `daemon stop` (#4654). Writes only into a directory that is
+ * already a Ruflo project or already has `.claude-flow/`, so `daemon stop` in an
+ * unrelated directory does not litter it. Best-effort; never throws.
+ */
+export declare function writeDaemonStopMarker(projectRoot: string): boolean;
+/** Clear the stop marker. Called by an explicit `daemon start` (#4654). Never throws. */
+export declare function clearDaemonStopMarker(projectRoot: string): void;
 /**
  * Return true only when the directory contains a durable Ruflo project marker.
  *

package/dist/src/services/daemon-autostart.js

@@ -81,6 +81,57 @@ function autostartDisabledByProjectConfig(projectRoot) {
     }
     return false;
 }
+/**
+ * #4654: an explicit `daemon stop` is an opt-out that must survive the next
+ * hook. Every ruflo-core plugin hook (PreToolUse/PostToolUse, PreCompact, Stop)
+ * runs the CLI, and the CLI auto-starts a daemon whenever none is alive, so a
+ * stopped daemon came back within minutes. `daemon stop` now writes this
+ * marker, auto-start honours it, and only an explicit `daemon start` clears it.
+ */
+export const DAEMON_STOP_MARKER = 'daemon.stopped';
+/**
+ * Set on the daemon that auto-start spawns, so that spawned `daemon start` does
+ * not clear a stop marker written after auto-start checked it (a `daemon stop`
+ * racing a hook). Only a user-driven start clears the marker.
+ */
+export const AUTOSTART_ENV = 'RUFLO_DAEMON_AUTOSTARTED';
+function stopMarkerPath(projectRoot) {
+    return path.join(projectRoot, '.claude-flow', DAEMON_STOP_MARKER);
+}
+/** True if the user explicitly stopped the daemon for this project (#4654). */
+export function isDaemonStopMarked(projectRoot) {
+    try {
+        return fs.existsSync(stopMarkerPath(projectRoot));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Record an explicit `daemon stop` (#4654). Writes only into a directory that is
+ * already a Ruflo project or already has `.claude-flow/`, so `daemon stop` in an
+ * unrelated directory does not litter it. Best-effort; never throws.
+ */
+export function writeDaemonStopMarker(projectRoot) {
+    try {
+        const dir = path.join(projectRoot, '.claude-flow');
+        if (!fs.existsSync(dir) && !isRufloProject(projectRoot))
+            return false;
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(stopMarkerPath(projectRoot), JSON.stringify({ stoppedAt: new Date().toISOString(), pid: process.pid }) + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Clear the stop marker. Called by an explicit `daemon start` (#4654). Never throws. */
+export function clearDaemonStopMarker(projectRoot) {
+    try {
+        fs.unlinkSync(stopMarkerPath(projectRoot));
+    }
+    catch { /* absent */ }
+}
 function autostartDisabled(projectRoot) {
     if (/^(0|false|no|off)$/i.test(process.env.RUFLO_DAEMON_AUTOSTART ?? ''))
         return true;
@@ -166,7 +217,7 @@ const defaultSpawn = (projectRoot) => {
         cwd: projectRoot,
         detached: true,
         stdio: 'ignore',
-        env: { ...process.env },
+        env: { ...process.env, [AUTOSTART_ENV]: '1' },
     });
     child.unref();
 };
@@ -186,6 +237,9 @@ export function ensureDaemonRunning(startDir, opts = {}) {
         if (!isRufloProject(projectRoot)) {
             return { started: false, reason: 'not a ruflo project' };
         }
+        if (isDaemonStopMarked(projectRoot)) {
+            return { started: false, reason: 'stopped by user (daemon stop); run `daemon start` to re-enable' };
+        }
         const alive = (opts.isAlive ?? isDaemonAlive)(projectRoot);
         if (alive)
             return { started: false, reason: 'already running' };

package/dist/src/services/headless-worker-executor.d.ts

@@ -123,6 +123,12 @@ export interface HeadlessExecutionResult {
     inputTokens?: number;
     outputTokens?: number;
     costUsd?: number;
+    /**
+     * When the stored claude.ai sign-in the worker ran under ends (ISO 8601),
+     * from `credential_expires_at` in the `claude -p` JSON result (Claude Code
+     * 2.1.318+). Absent for API-key auth and older CLIs.
+     */
+    credentialExpiresAt?: string;
     /** Model used for execution */
     model: string;
     /** Sandbox mode used */
@@ -202,7 +208,16 @@ export interface ClaudePrintEnvelope {
     outputTokens?: number;
     costUsd?: number;
     durationMs?: number;
+    /** ISO 8601 end of the stored claude.ai sign-in (Claude Code 2.1.318+). */
+    credentialExpiresAt?: string;
 }
+/** Days before a sign-in ends at which the executor emits 'credential-expiring' (matches Claude Code's own stderr warning). */
+export declare const CREDENTIAL_EXPIRY_WARN_DAYS = 10;
+/**
+ * Normalise `credential_expires_at` to ISO 8601. Accepts an ISO string or an
+ * epoch number (seconds or milliseconds); anything else is undefined.
+ */
+export declare function normalizeCredentialExpiry(v: unknown): string | undefined;
 /**
  * #2661 root-fix — best-effort parse of `claude --print --output-format
  * json`'s response envelope. Deliberately lenient: probes a couple of

package/dist/src/services/headless-worker-executor.js

@@ -337,6 +337,23 @@ export function isLocalWorker(type) {
 export function getModelId(model) {
     return MODEL_IDS[model];
 }
+/** Days before a sign-in ends at which the executor emits 'credential-expiring' (matches Claude Code's own stderr warning). */
+export const CREDENTIAL_EXPIRY_WARN_DAYS = 10;
+/**
+ * Normalise `credential_expires_at` to ISO 8601. Accepts an ISO string or an
+ * epoch number (seconds or milliseconds); anything else is undefined.
+ */
+export function normalizeCredentialExpiry(v) {
+    let ms;
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+        ms = v < 1e12 ? v * 1000 : v;
+    else if (typeof v === 'string' && v.trim()) {
+        const t = Date.parse(v);
+        if (Number.isFinite(t))
+            ms = t;
+    }
+    return ms === undefined ? undefined : new Date(ms).toISOString();
+}
 /**
  * #2661 root-fix — best-effort parse of `claude --print --output-format
  * json`'s response envelope. Deliberately lenient: probes a couple of
@@ -371,6 +388,7 @@ export function parseClaudePrintJsonEnvelope(raw) {
         outputTokens: numOrUndef(usage?.output_tokens ?? usage?.outputTokens),
         costUsd: numOrUndef(obj.total_cost_usd ?? obj.cost_usd ?? obj.totalCostUsd),
         durationMs: numOrUndef(obj.duration_ms ?? obj.durationMs),
+        credentialExpiresAt: normalizeCredentialExpiry(obj.credential_expires_at ?? obj.credentialExpiresAt),
     };
 }
 /**
@@ -779,7 +797,16 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                 executionId,
                 error: result.error,
                 ...(result.missingPlugins ? { missingPlugins: result.missingPlugins } : {}),
+                ...(result.credentialExpiresAt ? { credentialExpiresAt: result.credentialExpiresAt } : {}),
             };
+            // Claude Code 2.1.318: surface a claude.ai sign-in that ends soon, so the
+            // daemon can say so before workers start failing on auth.
+            if (result.credentialExpiresAt) {
+                const daysLeft = (Date.parse(result.credentialExpiresAt) - Date.now()) / 86_400_000;
+                if (daysLeft <= CREDENTIAL_EXPIRY_WARN_DAYS) {
+                    this.emit('credential-expiring', { expiresAt: result.credentialExpiresAt, daysLeft: Math.max(0, Math.floor(daysLeft)), workerType });
+                }
+            }
             // Log result
             this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
             // #2661 root-fix — structured per-launch telemetry, receipted
@@ -1182,6 +1209,7 @@ Analyze the above codebase context and provide your response following the forma
                         : undefined,
                     costUsd: envelope?.costUsd,
                     apiDurationMs: envelope?.durationMs,
+                    credentialExpiresAt: envelope?.credentialExpiresAt,
                     error: code !== 0 ? stderr || `Process exited with code ${code}` : undefined,
                 });
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.71.2",
+  "version": "3.71.3",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",