claude-flow 3.61.1 → 3.62.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.61.1",
+  "version": "3.62.0",
   "workspaces": [
     "v3/@claude-flow/codex",
     "v3/@claude-flow/mcp",

package/v3/@claude-flow/cli/catalog-manifest.json

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-24T04:53:21.744Z",
-  "gitSha": "e6c3743e",
+  "generatedAt": "2026-10-24T23:47:19.593Z",
+  "gitSha": "973d0ab4",
   "catalog": {
     "agents": 177,
-    "tools": 439,
+    "tools": 440,
     "skills": 34
   },
   "benchmark": null

package/v3/@claude-flow/cli/dist/src/mcp-tools/rure-tools.js

@@ -16,6 +16,7 @@ import { parseBinary, extractStrings, MAX_BINARY_BYTES } from '../rure/binary-pa
 import { parseDotNet } from '../rure/dotnet-parse.js';
 import { analyzeEvm, parseHex, MAX_EVM_BYTES } from '../rure/evm-parse.js';
 import { analyzeCuda } from '../rure/cuda-parse.js';
+import { planCuda, MAX_BLOCK_SIZES, MAX_DYNAMIC_SHARED_BYTES } from '../rure/cuda-plan.js';
 function fail(error) {
     return { content: [{ type: 'text', text: JSON.stringify({ success: false, error }) }], isError: true };
 }
@@ -408,5 +409,63 @@ export const rureTools = [
             }
         },
     },
+    {
+        name: 'rure_cuda_launch_plan',
+        description: 'Turn the static CUDA inventory of a program into a plan for measuring it (ADR-501): for each kernel of each architecture, its theoretical occupancy at a set of block sizes (blocks and warps resident per multiprocessor, and which resource sets the limit: registers, shared memory, warps or block slots), the block sizes that reach the most, and flags (local memory, register- or shared-memory-limited). The occupancy model reproduces NVIDIA\'s cuda_occupancy.h on every architecture it tabulates (sm_70, 75, 80, 86, 87, 89, 90, 120); any other architecture gets no figure. With includeHarness it also returns the text of a small CUDA driver-API program you can build to check the numbers on your own GPU and, with arguments you supply, to time launches. Nothing is compiled, loaded or run by this tool, and no text from the analyzed file reaches the harness. Occupancy bounds performance and does not predict it. Names from the file are untrusted and screened by AIDefence. Use when you have a CUDA binary, cubin or fatbin and need to decide which kernels and block sizes are worth benchmarking before running anything: rure_analyze_cuda alone lists registers and memory but not what they allow on a given GPU.',
+        category: 'rure',
+        tags: ['reverse-engineering', 'cuda', 'gpu', 'occupancy', 'benchmark-plan', 'static-analysis'],
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute path to a CUDA host binary (ELF/PE), a .fatbin or a .cubin file' },
+                arch: { type: 'string', description: 'Plan only this architecture, for example sm_86 (default: every architecture with compiled code in the file)' },
+                blockSizes: { type: 'array', items: { type: 'integer', minimum: 1, maximum: 1024 }, maxItems: MAX_BLOCK_SIZES, description: 'Block sizes to evaluate (default 32, 64, 96, 128, 192, 256, 384, 512, 768, 1024)' },
+                dynamicSharedBytes: { type: 'integer', minimum: 0, maximum: MAX_DYNAMIC_SHARED_BYTES, description: 'Dynamic shared memory per block the launch will use; it is not in the file (default 0)' },
+                includeHarness: { type: 'boolean', description: 'Also return the text of the occupancy-check / benchmark program (default false)' },
+            },
+            required: ['path'],
+        },
+        handler: async (input) => {
+            const v = validatePath(input.path, 'path');
+            if (!v.valid)
+                return fail(v.error);
+            if (input.arch !== undefined && (typeof input.arch !== 'string' || !/^sm_\d{2,3}$/.test(input.arch)))
+                return fail('arch must look like sm_86');
+            if (input.blockSizes !== undefined && !Array.isArray(input.blockSizes))
+                return fail('blockSizes must be an array of integers');
+            if (input.dynamicSharedBytes !== undefined && typeof input.dynamicSharedBytes !== 'number')
+                return fail('dynamicSharedBytes must be an integer');
+            try {
+                const r = readCapped(v.sanitized, MAX_BINARY_BYTES);
+                if (!r.ok)
+                    return fail(r.error);
+                const info = analyzeCuda(r.bytes, { includePtx: false });
+                const sc = new Screener();
+                const names = await sc.screen(info.kernels.map((k) => k.name));
+                const idents = await sc.screen(info.kernels.map((k) => k.identifier ?? ''));
+                const screened = { ...info, kernels: info.kernels.map((k, i) => ({ ...k, name: names[i], identifier: k.identifier === null ? null : idents[i] })) };
+                const plan = planCuda(screened, {
+                    ...(input.arch !== undefined && { arch: input.arch }),
+                    ...(input.blockSizes !== undefined && { blockSizes: input.blockSizes }),
+                    ...(input.dynamicSharedBytes !== undefined && { dynamicSharedBytes: input.dynamicSharedBytes }),
+                    includeHarness: input.includeHarness === true,
+                });
+                const kernels = plan.archs.reduce((n, a) => n + a.kernels.length, 0);
+                return ok({
+                    source: info.source,
+                    ...plan,
+                    summary: { archs: plan.archs.length, kernels },
+                    warnings: info.warnings,
+                    redactedCount: sc.redacted,
+                    screened: sc.screened,
+                });
+            }
+            catch (err) {
+                if (err instanceof RangeError)
+                    return fail(err.message);
+                return fail(`cuda launch plan failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+    },
 ];
 //# sourceMappingURL=rure-tools.js.map

package/v3/@claude-flow/cli/dist/src/rure/cuda-cubin.d.ts

@@ -29,6 +29,13 @@ export interface CubinInfo {
     warnings: string[];
     truncated: boolean;
 }
+/**
+ * The SM number in `e_flags`. Where it sits depends on the ABI the toolchain wrote: a cubin from CUDA 12 (ELF OS ABI 51) for sm_70 to sm_90 keeps it in the
+ * low byte (sm_70 is 0x460546: 0x46 twice, around the texture and address bits), while CUDA 13, and CUDA 12.8 for sm_120, use OS ABI 65 and the second byte
+ * (sm_80 is 0x06005004). Reading the second byte of an ABI 51 cubin gave "sm_5" for every one of them. An OS ABI we have not seen falls back to whichever
+ * byte is a plausible SM number.
+ */
+export declare function smOfFlags(flags: number, osAbi: number): number | null;
 export declare const isCubin: (b: Buffer) => boolean;
 /** `_Z5saxpyifPKfPf` -> `saxpy`; anything with a namespace, template or other prefix -> null. */
 export declare function simpleIdentifier(name: string): string | null;

package/v3/@claude-flow/cli/dist/src/rure/cuda-cubin.js

@@ -11,6 +11,22 @@ const NAME_MAX = 200;
 const STO_CUDA_ENTRY = 0x10;
 const EIATTR_REGCOUNT = 0x2f;
 const MAX_INFO_RECORDS = 4096;
+/**
+ * The SM number in `e_flags`. Where it sits depends on the ABI the toolchain wrote: a cubin from CUDA 12 (ELF OS ABI 51) for sm_70 to sm_90 keeps it in the
+ * low byte (sm_70 is 0x460546: 0x46 twice, around the texture and address bits), while CUDA 13, and CUDA 12.8 for sm_120, use OS ABI 65 and the second byte
+ * (sm_80 is 0x06005004). Reading the second byte of an ABI 51 cubin gave "sm_5" for every one of them. An OS ABI we have not seen falls back to whichever
+ * byte is a plausible SM number.
+ */
+export function smOfFlags(flags, osAbi) {
+    const low = flags & 0xff;
+    const second = (flags >>> 8) & 0xff;
+    const plausible = (n) => n >= 20 && n <= 199;
+    if (osAbi === 65)
+        return second;
+    if (osAbi === 51)
+        return low;
+    return plausible(second) ? second : plausible(low) ? low : null;
+}
 export const isCubin = (b) => b.length >= 0x40 && b[0] === 0x7f && b.toString('latin1', 1, 4) === 'ELF' && b[4] === 2 && b[5] === 1 && b.readUInt16LE(0x12) === EM_CUDA;
 const cstr = (b, at, end) => {
     if (at < 0 || at >= end)
@@ -59,8 +75,7 @@ export function parseCubin(b) {
         return info;
     }
     try {
-        const flags = b.readUInt32LE(0x30);
-        info.archFlag = (flags >>> 8) & 0xff;
+        info.archFlag = smOfFlags(b.readUInt32LE(0x30), b[7]);
         const shoff = Number(b.readBigUInt64LE(0x28));
         const entsize = b.readUInt16LE(0x3a);
         let count = b.readUInt16LE(0x3c);

package/v3/@claude-flow/cli/dist/src/rure/cuda-occupancy.d.ts

@@ -0,0 +1,59 @@
+/**
+ * ruRE CUDA launch plan, part 1 (ADR-501): theoretical occupancy from what the static reader found. Given an architecture's limits and a
+ * kernel's registers, static shared memory and a block size, how many blocks fit on one multiprocessor and which resource stops the next one.
+ * Pure arithmetic over a table: no device, no driver, nothing is run. The model is the one CUDA's occupancy calculator uses (warp, block,
+ * register and shared-memory limits, each with its allocation granularity); it was written here from that model and is checked, over the whole
+ * grid of resource combinations, against NVIDIA's own `cuda_occupancy.h` (rure-cuda-occupancy-oracle.test.ts) and on real devices.
+ * Theoretical occupancy bounds how many warps can be resident. It is not a performance number.
+ */
+export type Limiter = 'warps' | 'registers' | 'sharedMemory' | 'blocks' | 'barriers';
+/** Where a table row's numbers come from: read off a device by the CUDA runtime, or taken from NVIDIA's documentation. */
+export type Provenance = 'device-checked' | 'documentation';
+export interface ArchLimits {
+    /** `sm_NN`, as the fatbin names it. */
+    arch: string;
+    major: number;
+    minor: number;
+    maxThreadsPerSM: number;
+    maxBlocksPerSM: number;
+    maxThreadsPerBlock: number;
+    regsPerSM: number;
+    regsPerBlock: number;
+    maxRegsPerThread: number;
+    sharedPerSM: number;
+    sharedPerBlock: number;
+    sharedPerBlockOptin: number;
+    /** Shared memory the driver reserves in every block (counted against the block's allocation). */
+    sharedReservedPerBlock: number;
+    /**
+     * Whether a kernel's `.nv.shared.<kernel>` section already includes that reservation. From sm_90 it does (the compiler adds it, the driver reports
+     * the size without it, and the occupancy calculation adds it back), so the figure to use is the section size less the reservation.
+     */
+    cubinSharedIncludesReserve: boolean;
+    /** The shared-memory sizes an SM can be configured to, ascending; the SM's allocation rounds up to one of them. */
+    carveouts: readonly number[];
+    provenance: Provenance;
+}
+/** Architectures with a table. Anything else gets no occupancy figure rather than a guess. */
+export declare const ARCH_LIMITS: Readonly<Record<string, ArchLimits>>;
+export declare const limitsFor: (arch: string | null) => ArchLimits | null;
+export interface Kernel {
+    registers: number;
+    staticSharedBytes: number;
+    dynamicSharedBytes: number;
+    blockSize: number;
+}
+export interface Occupancy {
+    /** Blocks resident on one multiprocessor; 0 means the block cannot be launched at all. */
+    blocks: number;
+    /** Every resource that sets that number (ties are all listed). */
+    limiters: Limiter[];
+    /** What each resource alone would allow. */
+    limits: Record<Limiter, number>;
+    warpsPerBlock: number;
+    activeWarps: number;
+    /** activeWarps over the multiprocessor's warp capacity, 0 to 1. */
+    occupancy: number;
+}
+export declare function occupancy(l: ArchLimits, k: Kernel): Occupancy;
+//# sourceMappingURL=cuda-occupancy.d.ts.map

package/v3/@claude-flow/cli/dist/src/rure/cuda-occupancy.js

@@ -0,0 +1,69 @@
+/**
+ * ruRE CUDA launch plan, part 1 (ADR-501): theoretical occupancy from what the static reader found. Given an architecture's limits and a
+ * kernel's registers, static shared memory and a block size, how many blocks fit on one multiprocessor and which resource stops the next one.
+ * Pure arithmetic over a table: no device, no driver, nothing is run. The model is the one CUDA's occupancy calculator uses (warp, block,
+ * register and shared-memory limits, each with its allocation granularity); it was written here from that model and is checked, over the whole
+ * grid of resource combinations, against NVIDIA's own `cuda_occupancy.h` (rure-cuda-occupancy-oracle.test.ts) and on real devices.
+ * Theoretical occupancy bounds how many warps can be resident. It is not a performance number.
+ */
+const K = 1024;
+const WARP = 32;
+const REG_UNIT = 256;
+const SUB_PARTITIONS = 4;
+const base = { maxThreadsPerBlock: 1024, regsPerSM: 65536, regsPerBlock: 65536, maxRegsPerThread: 256, sharedPerBlock: 48 * K };
+const row = (arch, major, minor, o) => ({ arch, major, minor, ...base, ...o });
+/** Architectures with a table. Anything else gets no occupancy figure rather than a guess. */
+export const ARCH_LIMITS = Object.freeze({
+    sm_70: row('sm_70', 7, 0, { maxThreadsPerSM: 2048, maxBlocksPerSM: 32, sharedPerSM: 96 * K, sharedPerBlockOptin: 96 * K, sharedReservedPerBlock: 0, cubinSharedIncludesReserve: false, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 96 * K], provenance: 'documentation' }),
+    sm_75: row('sm_75', 7, 5, { maxThreadsPerSM: 1024, maxBlocksPerSM: 16, sharedPerSM: 64 * K, sharedPerBlockOptin: 64 * K, sharedReservedPerBlock: 0, cubinSharedIncludesReserve: false, carveouts: [32 * K, 64 * K], provenance: 'documentation' }),
+    sm_80: row('sm_80', 8, 0, { maxThreadsPerSM: 2048, maxBlocksPerSM: 32, sharedPerSM: 164 * K, sharedPerBlockOptin: 163 * K, sharedReservedPerBlock: K, cubinSharedIncludesReserve: false, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 100 * K, 132 * K, 164 * K], provenance: 'device-checked' }),
+    sm_86: row('sm_86', 8, 6, { maxThreadsPerSM: 1536, maxBlocksPerSM: 16, sharedPerSM: 100 * K, sharedPerBlockOptin: 99 * K, sharedReservedPerBlock: K, cubinSharedIncludesReserve: false, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 100 * K], provenance: 'device-checked' }),
+    sm_87: row('sm_87', 8, 7, { maxThreadsPerSM: 1536, maxBlocksPerSM: 16, sharedPerSM: 164 * K, sharedPerBlockOptin: 163 * K, sharedReservedPerBlock: K, cubinSharedIncludesReserve: false, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 100 * K, 132 * K, 164 * K], provenance: 'documentation' }),
+    sm_89: row('sm_89', 8, 9, { maxThreadsPerSM: 1536, maxBlocksPerSM: 24, sharedPerSM: 100 * K, sharedPerBlockOptin: 99 * K, sharedReservedPerBlock: K, cubinSharedIncludesReserve: false, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 100 * K], provenance: 'device-checked' }),
+    sm_90: row('sm_90', 9, 0, { maxThreadsPerSM: 2048, maxBlocksPerSM: 32, sharedPerSM: 228 * K, sharedPerBlockOptin: 227 * K, sharedReservedPerBlock: K, cubinSharedIncludesReserve: true, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 100 * K, 132 * K, 164 * K, 196 * K, 228 * K], provenance: 'device-checked' }),
+    sm_120: row('sm_120', 12, 0, { maxThreadsPerSM: 1536, maxBlocksPerSM: 24, sharedPerSM: 100 * K, sharedPerBlockOptin: 99 * K, sharedReservedPerBlock: K, cubinSharedIncludesReserve: true, carveouts: [0, 8 * K, 16 * K, 32 * K, 64 * K, 100 * K], provenance: 'device-checked' }),
+});
+export const limitsFor = (arch) => (arch !== null && Object.hasOwn(ARCH_LIMITS, arch) ? ARCH_LIMITS[arch] : null);
+const up = (n, unit) => Math.ceil(n / unit) * unit;
+const FOREVER = Number.MAX_SAFE_INTEGER;
+const whole = (v, name, min) => {
+    if (!Number.isInteger(v) || v < min || v > 2 ** 31)
+        throw new RangeError(`${name} must be an integer from ${min}`);
+};
+/** The block's shared-memory allocation, rounded up to the smallest configuration the multiprocessor offers; null when none is large enough. */
+const carveoutFor = (l, bytes) => l.carveouts.find((size) => bytes <= size && (bytes > 0 || size === 0 || l.major === 7)) ?? null;
+export function occupancy(l, k) {
+    whole(k.registers, 'registers', 0);
+    whole(k.staticSharedBytes, 'staticSharedBytes', 0);
+    whole(k.dynamicSharedBytes, 'dynamicSharedBytes', 0);
+    whole(k.blockSize, 'blockSize', 1);
+    const warps = Math.ceil(k.blockSize / WARP);
+    const warpCapacity = l.maxThreadsPerSM / WARP;
+    const byWarps = k.blockSize > l.maxThreadsPerBlock ? 0 : Math.floor(warpCapacity / warps);
+    const byBlocks = l.maxBlocksPerSM;
+    const perWarp = up(k.registers * WARP, REG_UNIT);
+    const perBlock = perWarp * warps;
+    const assumed = perWarp * up(warps, SUB_PARTITIONS);
+    let byRegisters = FOREVER;
+    if (l.regsPerBlock < assumed || l.regsPerBlock < perBlock || k.registers > l.maxRegsPerThread)
+        byRegisters = 0;
+    else if (perWarp > 0)
+        byRegisters = Math.floor((Math.floor(l.regsPerSM / SUB_PARTITIONS / perWarp) * SUB_PARTITIONS) / warps);
+    const granule = l.major >= 8 ? 128 : 256;
+    const allocated = up(k.staticSharedBytes + l.sharedReservedPerBlock + k.dynamicSharedBytes, granule);
+    const blockLimit = l.sharedPerBlock + (l.major >= 8 ? l.sharedReservedPerBlock : 0);
+    let bySharedMemory = 0;
+    if (allocated <= blockLimit) {
+        const preferred = carveoutFor(l, l.sharedPerSM);
+        const fits = preferred !== null && preferred >= allocated ? preferred : l.major >= 7 ? carveoutFor(l, allocated) : l.sharedPerSM;
+        bySharedMemory = fits === null ? 0 : allocated > 0 ? Math.floor(fits / allocated) : FOREVER;
+    }
+    // From compute capability 9 each resident block holds a hardware barrier; a kernel using one barrier (the default) is held to the slots there are.
+    // On sm_90 there are two per block slot, so this never binds; on sm_120 there is one, so it ties with the block limit and NVIDIA reports both.
+    const byBarriers = l.major < 9 ? FOREVER : l.major === 9 ? byBlocks * 2 : byBlocks;
+    const limits = { warps: byWarps, registers: byRegisters, sharedMemory: bySharedMemory, blocks: byBlocks, barriers: byBarriers };
+    const blocks = Math.min(byWarps, byRegisters, bySharedMemory, byBlocks, byBarriers);
+    const order = ['warps', 'registers', 'sharedMemory', 'blocks', 'barriers'];
+    return { blocks, limiters: order.filter((name) => limits[name] === blocks), limits, warpsPerBlock: warps, activeWarps: blocks * warps, occupancy: (blocks * warps) / warpCapacity };
+}
+//# sourceMappingURL=cuda-occupancy.js.map

package/v3/@claude-flow/cli/dist/src/rure/cuda-plan.d.ts

@@ -0,0 +1,84 @@
+/**
+ * ruRE CUDA launch plan, part 2 (ADR-501): what `analyzeCuda` found, turned into a plan for measuring. For each kernel of each architecture: the
+ * theoretical occupancy at a set of block sizes, what limits it, and a few plain flags; and, on request, a small CUDA driver-API program (as text)
+ * that a person can build and run to check those numbers on their own GPU. Pure: data in, data and text out. Nothing here compiles, loads or runs
+ * GPU code, and the harness text holds nothing taken from the analyzed file (the kernel name and the file are arguments to the program).
+ */
+import type { CudaInfo } from './cuda-parse.js';
+import { type Limiter, type Provenance } from './cuda-occupancy.js';
+export declare const DEFAULT_BLOCK_SIZES: readonly number[];
+export declare const MAX_BLOCK_SIZES = 24;
+export declare const MAX_DYNAMIC_SHARED_BYTES: number;
+export declare const MAX_PLANNED_KERNELS = 200;
+export interface PlanOptions {
+    /** Only this architecture (`sm_86`). */
+    arch?: string;
+    blockSizes?: readonly number[];
+    /** Dynamic shared memory per block the launch will ask for; it is not in the file, so it is a parameter. */
+    dynamicSharedBytes?: number;
+    includeHarness?: boolean;
+}
+export type PlanFlag = 'local-memory' | 'register-limited' | 'shared-memory-limited';
+export interface PlannedBlockSize {
+    blockSize: number;
+    activeBlocksPerSM: number;
+    activeWarpsPerSM: number;
+    /** 0 to 1, four places. */
+    occupancy: number;
+    limitedBy: Limiter[];
+}
+export interface PlannedKernel {
+    name: string;
+    identifier: string | null;
+    /** `staticSharedBytes` is the figure the driver and occupancy calculation use; `sharedSectionBytes` is what the file's section says (cuobjdump's SHARED), which differs on sm_90 and later. */
+    resources: {
+        registers: number | null;
+        staticSharedBytes: number;
+        sharedSectionBytes: number;
+        localBytes: number;
+        constantBytes: number | null;
+        codeBytes: number | null;
+    };
+    /** Absent when the file gave no register count: occupancy cannot be worked out without it. */
+    blockSizes?: PlannedBlockSize[];
+    best?: {
+        blockSizes: number[];
+        occupancy: number;
+        limitedBy: Limiter[];
+    };
+    flags: PlanFlag[];
+    note?: string;
+}
+export interface PlannedArch {
+    arch: string;
+    /** False when there is no limits table for this architecture; then there are no kernels below. */
+    supported: boolean;
+    provenance: Provenance | null;
+    limits?: {
+        maxThreadsPerSM: number;
+        maxBlocksPerSM: number;
+        regsPerSM: number;
+        sharedPerSM: number;
+        sharedReservedPerBlock: number;
+    };
+    kernels: PlannedKernel[];
+    note?: string;
+}
+export interface LaunchPlan {
+    archs: PlannedArch[];
+    blockSizes: number[];
+    dynamicSharedBytes: number;
+    assumptions: string[];
+    harness?: string;
+    truncated: boolean;
+}
+export declare const ASSUMPTIONS: readonly string[];
+export declare function planCuda(info: CudaInfo, options?: PlanOptions): LaunchPlan;
+/**
+ * A program a person can build and run. It is text, fixed in this file: it contains nothing from the analyzed file. Run as
+ *   ./occ_check <file.cubin|file.fatbin> <kernel name as listed> [dynamicSharedBytes]
+ * it asks the CUDA driver how many blocks fit per multiprocessor at each block size (compare with the plan), and, if built with -DRURE_BENCH and a
+ * rure_bench.h of your own that sets up the kernel's arguments, times launches. It loads the file's code onto the GPU; the benchmark mode runs it.
+ */
+export declare const HARNESS_SOURCE = "// occ_check.cpp: written by ruflo's rure_cuda_launch_plan. ruRE did not build or run this; building and running it is your decision.\n// Build:  nvcc -O2 -o occ_check occ_check.cpp -lcuda            (add -DRURE_BENCH with your own rure_bench.h to time launches)\n// Run:    ./occ_check <file.cubin|file.fatbin> <kernel name> [dynamicSharedBytes]\n// Without RURE_BENCH it loads the code onto device 0 and asks the driver for occupancy; it launches nothing.\n// With RURE_BENCH it LAUNCHES THE KERNEL with the arguments your rure_bench.h gives it. Only do that for code you trust, on a GPU you can spare.\n#include <cuda.h>\n#include <algorithm>\n#include <cstdio>\n#include <cstdlib>\n#include <fstream>\n#include <iterator>\n#include <vector>\n#ifdef RURE_BENCH\n// rure_bench.h must define:\n//   bool rure_prepare(void*** kernelParams);   allocate buffers, fill an array of pointers to the kernel's arguments\n//   unsigned rure_grid(int blockSize);         how many blocks to launch at this block size\n//   void rure_release();\n#include \"rure_bench.h\"\n#endif\n\n#define CK(call) do { CUresult r_ = (call); if (r_ != CUDA_SUCCESS) { const char* m_ = nullptr; cuGetErrorString(r_, &m_); fprintf(stderr, \"line %d: %s\\n\", __LINE__, m_ ? m_ : \"error\"); return 1; } } while (0)\n\nint main(int argc, char** argv) {\n  if (argc < 3) { fprintf(stderr, \"usage: %s <file.cubin|file.fatbin> <kernel name> [dynamicSharedBytes]\\n\", argv[0]); return 2; }\n  size_t dyn = argc > 3 ? strtoull(argv[3], nullptr, 10) : 0;\n  std::ifstream in(argv[1], std::ios::binary);\n  std::vector<char> image((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());\n  if (image.empty()) { fprintf(stderr, \"cannot read %s\\n\", argv[1]); return 2; }\n\n  CK(cuInit(0));\n  CUdevice dev; CK(cuDeviceGet(&dev, 0));\n  CUcontext ctx; CK(cuDevicePrimaryCtxRetain(&ctx, dev)); CK(cuCtxSetCurrent(ctx));\n  CUmodule mod; CK(cuModuleLoadData(&mod, image.data()));\n  CUfunction fn; CK(cuModuleGetFunction(&fn, mod, argv[2]));\n\n  int regs, shared, local, maxThreads, maxThreadsSM, major, minor, blocksSM, regsSM, sharedSM, reserved, optin;\n  CK(cuFuncGetAttribute(&regs, CU_FUNC_ATTRIBUTE_NUM_REGS, fn));\n  CK(cuFuncGetAttribute(&shared, CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, fn));\n  CK(cuFuncGetAttribute(&local, CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES, fn));\n  CK(cuFuncGetAttribute(&maxThreads, CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK, fn));\n  CK(cuDeviceGetAttribute(&maxThreadsSM, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR, dev));\n  CK(cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, dev));\n  CK(cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, dev));\n  CK(cuDeviceGetAttribute(&blocksSM, CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR, dev));\n  CK(cuDeviceGetAttribute(&regsSM, CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR, dev));\n  CK(cuDeviceGetAttribute(&sharedSM, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR, dev));\n  CK(cuDeviceGetAttribute(&reserved, CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK, dev));\n  CK(cuDeviceGetAttribute(&optin, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN, dev));\n  printf(\"device sm_%d%d: maxThreadsPerSM %d, maxBlocksPerSM %d, regsPerSM %d, sharedPerSM %d, sharedReservedPerBlock %d, sharedPerBlockOptin %d\\n\", major, minor, maxThreadsSM, blocksSM, regsSM, sharedSM, reserved, optin);\n  printf(\"kernel: registers %d, static shared %d, local %d, max threads per block %d\\n\", regs, shared, local, maxThreads);\n  printf(\"blockSize activeBlocksPerSM activeWarpsPerSM occupancy%s\\n\",\n#ifdef RURE_BENCH\n         \" medianMs\");\n#else\n         \"\");\n#endif\n\n  const int sizes[] = {32, 64, 96, 128, 192, 256, 384, 512, 768, 1024};\n  for (int b : sizes) {\n    int blocks = 0;\n    if (cuOccupancyMaxActiveBlocksPerMultiprocessor(&blocks, fn, b, dyn) != CUDA_SUCCESS) blocks = 0;\n    int warps = blocks * ((b + 31) / 32);\n    printf(\"%d %d %d %.4f\", b, blocks, warps, (double)warps / (maxThreadsSM / 32));\n#ifdef RURE_BENCH\n    double ms = -1;\n    if (blocks > 0) {\n      void** params = nullptr;\n      if (!rure_prepare(&params)) { fprintf(stderr, \"rure_prepare failed\\n\"); return 1; }\n      CUevent t0, t1; CK(cuEventCreate(&t0, CU_EVENT_DEFAULT)); CK(cuEventCreate(&t1, CU_EVENT_DEFAULT));\n      std::vector<float> times;\n      for (int i = 0; i < 23; i++) {\n        CK(cuEventRecord(t0, 0));\n        CK(cuLaunchKernel(fn, rure_grid(b), 1, 1, b, 1, 1, (unsigned)dyn, 0, params, 0));\n        CK(cuEventRecord(t1, 0)); CK(cuEventSynchronize(t1));\n        float t; CK(cuEventElapsedTime(&t, t0, t1));\n        if (i >= 3) times.push_back(t);\n      }\n      std::sort(times.begin(), times.end());\n      ms = times[times.size() / 2];\n      rure_release();\n    }\n    printf(\" %.4f\", ms);\n#endif\n    printf(\"\\n\");\n  }\n  return 0;\n}\n";
+//# sourceMappingURL=cuda-plan.d.ts.map

package/v3/@claude-flow/cli/dist/src/rure/cuda-plan.js

@@ -0,0 +1,197 @@
+import { limitsFor, occupancy } from './cuda-occupancy.js';
+export const DEFAULT_BLOCK_SIZES = [32, 64, 96, 128, 192, 256, 384, 512, 768, 1024];
+export const MAX_BLOCK_SIZES = 24;
+export const MAX_DYNAMIC_SHARED_BYTES = 1024 * 1024;
+export const MAX_PLANNED_KERNELS = 200;
+export const ASSUMPTIONS = [
+    'Theoretical occupancy: how many warps can be resident on one multiprocessor given the kernel\'s registers and static shared memory. It bounds, and does not predict, performance.',
+    'Static shared memory is the amount in the file, less the 1 KiB the driver reserves per block where the compiler folds it into that figure (sm_90 and later); a kernel with no static shared section uses none. Dynamic shared memory is not in the file, so it is the dynamicSharedBytes parameter (default 0), the same for every kernel.',
+    'Default shared-memory carveout and cache configuration, one block barrier per block (the default), no cluster launch, and no opt-in to more than 48 KiB of shared memory per block.',
+    'The registers in the file are what the compiler chose for that architecture; the driver may JIT PTX to different numbers.',
+    'Running the plan is a separate step that you take; nothing here compiles or runs GPU code.',
+];
+const round4 = (n) => Math.round(n * 10_000) / 10_000;
+function cleanSizes(sizes) {
+    const wanted = sizes === undefined ? [...DEFAULT_BLOCK_SIZES] : [...sizes];
+    if (wanted.length === 0 || wanted.length > MAX_BLOCK_SIZES)
+        throw new RangeError(`blockSizes must hold 1 to ${MAX_BLOCK_SIZES} sizes`);
+    for (const size of wanted)
+        if (!Number.isInteger(size) || size < 1 || size > 1024)
+            throw new RangeError('each block size must be an integer from 1 to 1024');
+    return [...new Set(wanted)].sort((a, b) => a - b);
+}
+function planKernel(kernel, arch, sizes, dynamic) {
+    const limits = limitsFor(arch);
+    const sectionShared = kernel.sharedBytes ?? 0;
+    const staticShared = Math.max(0, sectionShared - (limits.cubinSharedIncludesReserve ? limits.sharedReservedPerBlock : 0));
+    const local = kernel.localBytes ?? 0;
+    const out = {
+        name: kernel.name,
+        identifier: kernel.identifier,
+        resources: { registers: kernel.registers, staticSharedBytes: staticShared, sharedSectionBytes: sectionShared, localBytes: local, constantBytes: kernel.constantBytes, codeBytes: kernel.codeBytes },
+        flags: [],
+    };
+    if (local > 0)
+        out.flags.push('local-memory');
+    if (kernel.registers === null || kernel.registers < 1) {
+        out.note = 'the file holds no register count for this kernel, so occupancy cannot be worked out';
+        return out;
+    }
+    out.blockSizes = sizes.map((blockSize) => {
+        const r = occupancy(limits, { registers: kernel.registers, staticSharedBytes: staticShared, dynamicSharedBytes: dynamic, blockSize });
+        return { blockSize, activeBlocksPerSM: r.blocks, activeWarpsPerSM: r.activeWarps, occupancy: round4(r.occupancy), limitedBy: r.limiters };
+    });
+    const top = Math.max(...out.blockSizes.map((b) => b.occupancy));
+    const best = out.blockSizes.filter((b) => b.occupancy === top);
+    if (top > 0) {
+        // The limiters at the smallest best size are the ones to report: a larger one only repeats them.
+        const first = best[0];
+        out.best = { blockSizes: best.map((b) => b.blockSize), occupancy: top, limitedBy: first.limitedBy };
+        if (top < 1 && first.limitedBy.includes('registers'))
+            out.flags.push('register-limited');
+        if (top < 1 && first.limitedBy.includes('sharedMemory'))
+            out.flags.push('shared-memory-limited');
+    }
+    else
+        out.note = 'no listed block size can launch with these resources';
+    return out;
+}
+export function planCuda(info, options = {}) {
+    const sizes = cleanSizes(options.blockSizes);
+    const dynamic = options.dynamicSharedBytes ?? 0;
+    if (!Number.isInteger(dynamic) || dynamic < 0 || dynamic > MAX_DYNAMIC_SHARED_BYTES)
+        throw new RangeError(`dynamicSharedBytes must be an integer from 0 to ${MAX_DYNAMIC_SHARED_BYTES}`);
+    const wanted = options.arch === undefined ? info.cubinArchs : [options.arch];
+    const archs = [];
+    let planned = 0;
+    let truncated = false;
+    for (const arch of wanted) {
+        const limits = limitsFor(arch);
+        if (limits === null) {
+            archs.push({ arch, supported: false, provenance: null, kernels: [], note: `no occupancy limits are tabulated for ${arch}` });
+            continue;
+        }
+        const entries = info.kernels.filter((kernel) => kernel.isEntry && kernel.arch === arch);
+        const kernels = [];
+        for (const kernel of entries) {
+            if (planned >= MAX_PLANNED_KERNELS) {
+                truncated = true;
+                break;
+            }
+            kernels.push(planKernel(kernel, arch, sizes, dynamic));
+            planned++;
+        }
+        archs.push({
+            arch,
+            supported: true,
+            provenance: limits.provenance,
+            limits: { maxThreadsPerSM: limits.maxThreadsPerSM, maxBlocksPerSM: limits.maxBlocksPerSM, regsPerSM: limits.regsPerSM, sharedPerSM: limits.sharedPerSM, sharedReservedPerBlock: limits.sharedReservedPerBlock },
+            kernels,
+            ...(entries.length === 0 && { note: `${arch} is in the file but holds no launchable kernel` }),
+        });
+    }
+    const noCubins = info.cubinArchs.length === 0;
+    return {
+        archs,
+        blockSizes: sizes,
+        dynamicSharedBytes: dynamic,
+        assumptions: [...ASSUMPTIONS, ...(noCubins ? ['The file holds no compiled code for any architecture (PTX only, or nothing readable), so there are no register counts to plan from.'] : [])],
+        ...(options.includeHarness === true && { harness: HARNESS_SOURCE }),
+        truncated,
+    };
+}
+/**
+ * A program a person can build and run. It is text, fixed in this file: it contains nothing from the analyzed file. Run as
+ *   ./occ_check <file.cubin|file.fatbin> <kernel name as listed> [dynamicSharedBytes]
+ * it asks the CUDA driver how many blocks fit per multiprocessor at each block size (compare with the plan), and, if built with -DRURE_BENCH and a
+ * rure_bench.h of your own that sets up the kernel's arguments, times launches. It loads the file's code onto the GPU; the benchmark mode runs it.
+ */
+export const HARNESS_SOURCE = `// occ_check.cpp: written by ruflo's rure_cuda_launch_plan. ruRE did not build or run this; building and running it is your decision.
+// Build:  nvcc -O2 -o occ_check occ_check.cpp -lcuda            (add -DRURE_BENCH with your own rure_bench.h to time launches)
+// Run:    ./occ_check <file.cubin|file.fatbin> <kernel name> [dynamicSharedBytes]
+// Without RURE_BENCH it loads the code onto device 0 and asks the driver for occupancy; it launches nothing.
+// With RURE_BENCH it LAUNCHES THE KERNEL with the arguments your rure_bench.h gives it. Only do that for code you trust, on a GPU you can spare.
+#include <cuda.h>
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iterator>
+#include <vector>
+#ifdef RURE_BENCH
+// rure_bench.h must define:
+//   bool rure_prepare(void*** kernelParams);   allocate buffers, fill an array of pointers to the kernel's arguments
+//   unsigned rure_grid(int blockSize);         how many blocks to launch at this block size
+//   void rure_release();
+#include "rure_bench.h"
+#endif
+
+#define CK(call) do { CUresult r_ = (call); if (r_ != CUDA_SUCCESS) { const char* m_ = nullptr; cuGetErrorString(r_, &m_); fprintf(stderr, "line %d: %s\\n", __LINE__, m_ ? m_ : "error"); return 1; } } while (0)
+
+int main(int argc, char** argv) {
+  if (argc < 3) { fprintf(stderr, "usage: %s <file.cubin|file.fatbin> <kernel name> [dynamicSharedBytes]\\n", argv[0]); return 2; }
+  size_t dyn = argc > 3 ? strtoull(argv[3], nullptr, 10) : 0;
+  std::ifstream in(argv[1], std::ios::binary);
+  std::vector<char> image((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+  if (image.empty()) { fprintf(stderr, "cannot read %s\\n", argv[1]); return 2; }
+
+  CK(cuInit(0));
+  CUdevice dev; CK(cuDeviceGet(&dev, 0));
+  CUcontext ctx; CK(cuDevicePrimaryCtxRetain(&ctx, dev)); CK(cuCtxSetCurrent(ctx));
+  CUmodule mod; CK(cuModuleLoadData(&mod, image.data()));
+  CUfunction fn; CK(cuModuleGetFunction(&fn, mod, argv[2]));
+
+  int regs, shared, local, maxThreads, maxThreadsSM, major, minor, blocksSM, regsSM, sharedSM, reserved, optin;
+  CK(cuFuncGetAttribute(&regs, CU_FUNC_ATTRIBUTE_NUM_REGS, fn));
+  CK(cuFuncGetAttribute(&shared, CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, fn));
+  CK(cuFuncGetAttribute(&local, CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES, fn));
+  CK(cuFuncGetAttribute(&maxThreads, CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK, fn));
+  CK(cuDeviceGetAttribute(&maxThreadsSM, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, dev));
+  CK(cuDeviceGetAttribute(&minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, dev));
+  CK(cuDeviceGetAttribute(&blocksSM, CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&regsSM, CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&sharedSM, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR, dev));
+  CK(cuDeviceGetAttribute(&reserved, CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK, dev));
+  CK(cuDeviceGetAttribute(&optin, CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN, dev));
+  printf("device sm_%d%d: maxThreadsPerSM %d, maxBlocksPerSM %d, regsPerSM %d, sharedPerSM %d, sharedReservedPerBlock %d, sharedPerBlockOptin %d\\n", major, minor, maxThreadsSM, blocksSM, regsSM, sharedSM, reserved, optin);
+  printf("kernel: registers %d, static shared %d, local %d, max threads per block %d\\n", regs, shared, local, maxThreads);
+  printf("blockSize activeBlocksPerSM activeWarpsPerSM occupancy%s\\n",
+#ifdef RURE_BENCH
+         " medianMs");
+#else
+         "");
+#endif
+
+  const int sizes[] = {32, 64, 96, 128, 192, 256, 384, 512, 768, 1024};
+  for (int b : sizes) {
+    int blocks = 0;
+    if (cuOccupancyMaxActiveBlocksPerMultiprocessor(&blocks, fn, b, dyn) != CUDA_SUCCESS) blocks = 0;
+    int warps = blocks * ((b + 31) / 32);
+    printf("%d %d %d %.4f", b, blocks, warps, (double)warps / (maxThreadsSM / 32));
+#ifdef RURE_BENCH
+    double ms = -1;
+    if (blocks > 0) {
+      void** params = nullptr;
+      if (!rure_prepare(&params)) { fprintf(stderr, "rure_prepare failed\\n"); return 1; }
+      CUevent t0, t1; CK(cuEventCreate(&t0, CU_EVENT_DEFAULT)); CK(cuEventCreate(&t1, CU_EVENT_DEFAULT));
+      std::vector<float> times;
+      for (int i = 0; i < 23; i++) {
+        CK(cuEventRecord(t0, 0));
+        CK(cuLaunchKernel(fn, rure_grid(b), 1, 1, b, 1, 1, (unsigned)dyn, 0, params, 0));
+        CK(cuEventRecord(t1, 0)); CK(cuEventSynchronize(t1));
+        float t; CK(cuEventElapsedTime(&t, t0, t1));
+        if (i >= 3) times.push_back(t);
+      }
+      std::sort(times.begin(), times.end());
+      ms = times[times.size() / 2];
+      rure_release();
+    }
+    printf(" %.4f", ms);
+#endif
+    printf("\\n");
+  }
+  return 0;
+}
+`;
+//# sourceMappingURL=cuda-plan.js.map

package/v3/@claude-flow/cli/dist/src/services/headless-worker-executor.js

@@ -584,7 +584,12 @@ export class HeadlessWorkerExecutor extends EventEmitter {
             return false;
         }
         clearTimeout(entry.timeout);
-        this.killEntryTree(entry.process, 'SIGTERM');
+        if (entry.abort) {
+            entry.abort();
+        }
+        else {
+            this.killEntryTree(entry.process, 'SIGTERM');
+        }
         this.processPool.delete(executionId);
         this.emit('cancelled', { executionId });
         // Process next in queue
@@ -600,15 +605,21 @@ export class HeadlessWorkerExecutor extends EventEmitter {
         const entries = Array.from(this.processPool.entries());
         for (const [executionId, entry] of entries) {
             clearTimeout(entry.timeout);
-            this.killEntryTree(entry.process, 'SIGTERM');
-            // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
-            setTimeout(() => {
-                try {
-                    if (!entry.process.killed)
-                        this.killEntryTree(entry.process, 'SIGKILL');
-                }
-                catch { /* already dead */ }
-            }, 5000).unref();
+            if (entry.abort) {
+                // Settles the promise and owns the SIGTERM -> SIGKILL escalation (#4463).
+                entry.abort();
+            }
+            else {
+                this.killEntryTree(entry.process, 'SIGTERM');
+                // SIGKILL fallback after 5s to prevent orphan processes (#1395 Bug 6)
+                setTimeout(() => {
+                    try {
+                        if (entry.process.exitCode === null && entry.process.signalCode === null)
+                            this.killEntryTree(entry.process, 'SIGKILL');
+                    }
+                    catch { /* already dead */ }
+                }, 5000).unref();
+            }
             this.emit('cancelled', { executionId });
             cancelled++;
         }
@@ -1075,16 +1086,31 @@ Analyze the above codebase context and provide your response following the forma
                 }
                 catch { /* already dead */ }
             };
+            // #4463 — `child.killed` only means a signal was delivered, not that the
+            // child exited, so escalation keys off the exit state instead.
+            const hasExited = () => child.exitCode !== null || child.signalCode !== null;
+            let escalationHandle;
+            let deadlineHandle;
+            const terminate = () => {
+                if (escalationHandle)
+                    return; // already signalled; never repeat SIGTERM
+                killTree('SIGTERM');
+                // Give it a moment to terminate gracefully, then force it.
+                escalationHandle = setTimeout(() => {
+                    if (!hasExited())
+                        killTree('SIGKILL');
+                }, 5000);
+            };
+            const stopTimers = () => {
+                clearTimeout(escalationHandle);
+                clearTimeout(deadlineHandle);
+            };
+            child.once('exit', () => clearTimeout(escalationHandle));
+            child.once('close', stopTimers);
             // Setup timeout
             const timeoutHandle = setTimeout(() => {
                 if (this.processPool.has(options.executionId)) {
-                    killTree('SIGTERM');
-                    // Give it a moment to terminate gracefully
-                    setTimeout(() => {
-                        if (!child.killed) {
-                            killTree('SIGKILL');
-                        }
-                    }, 5000);
+                    terminate();
                 }
             }, options.timeoutMs);
             // Track in process pool
@@ -1101,8 +1127,17 @@ Analyze the above codebase context and provide your response following the forma
             let resolved = false;
             const cleanup = () => {
                 clearTimeout(timeoutHandle);
+                clearTimeout(deadlineHandle);
                 this.processPool.delete(options.executionId);
             };
+            poolEntry.abort = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                terminate();
+                cleanup();
+                resolve({ success: false, output: stdout || stderr, error: 'Execution cancelled' });
+            };
             child.stdout?.on('data', (data) => {
                 const chunk = data.toString();
                 stdout += chunk;
@@ -1152,13 +1187,15 @@ Analyze the above codebase context and provide your response following the forma
                 });
             });
             // Handle timeout
-            setTimeout(() => {
+            deadlineHandle = setTimeout(() => {
                 if (resolved)
                     return;
                 if (!this.processPool.has(options.executionId))
                     return;
                 resolved = true;
-                killTree('SIGTERM');
+                // Normally a no-op: the timeout handler above already signalled the
+                // tree and owns the SIGKILL escalation (no duplicate SIGTERM).
+                terminate();
                 cleanup();
                 resolve({
                     success: false,

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.d.ts

@@ -90,6 +90,7 @@ export declare class WorkerDaemon extends EventEmitter {
     private headlessInitPromise;
     private originalConfig?;
     private fileConfigResourceThresholds?;
+    private fileConfigScalars?;
     private gitIdentity;
     private lastSupervisorRenewalMs;
     constructor(projectRoot: string, config?: Partial<DaemonConfig>);

package/v3/@claude-flow/cli/dist/src/services/worker-daemon.js

@@ -143,6 +143,8 @@ export class WorkerDaemon extends EventEmitter {
     // originalConfig — so a config.json override kept losing to whatever
     // .claude-flow/daemon-state.json had persisted from a previous run.
     fileConfigResourceThresholds;
+    // #4462 — the same record for maxConcurrent / workerTimeoutMs.
+    fileConfigScalars;
     // #2661 root-fix — resolved once (git identity doesn't change at runtime)
     // and reused for lease heartbeats + supervisor election, both gated on
     // aiWorkersEnabled since they only matter for the recurring AI schedule.
@@ -161,6 +163,7 @@ export class WorkerDaemon extends EventEmitter {
             maxCpuLoad: fileConfig.maxCpuLoad,
             minFreeMemoryPercent: fileConfig.minFreeMemoryPercent,
         };
+        this.fileConfigScalars = { maxConcurrent: fileConfig.maxConcurrent, workerTimeoutMs: fileConfig.workerTimeoutMs };
         // CPU-proportional smart default instead of hardcoded 2.0
         const cpuCount = WorkerDaemon.getEffectiveCpuCount();
         let smartMaxCpuLoad = Math.max(cpuCount * 0.8, 2.0); // Floor of 2.0 for single-CPU machines
@@ -691,10 +694,16 @@ export class WorkerDaemon extends EventEmitter {
                         this.config.resourceThresholds.minFreeMemoryPercent = rt.minFreeMemoryPercent;
                     }
                 }
-                if (typeof saved.config?.maxConcurrent === 'number' && saved.config.maxConcurrent > 0) {
+                // #4462 — same rule for the two scalar fields: constructor arg or
+                // config.json beats saved state, which only fills in what neither set.
+                const maxConcurrentExplicit = this.originalConfig?.maxConcurrent !== undefined
+                    || this.fileConfigScalars?.maxConcurrent !== undefined;
+                const workerTimeoutExplicit = this.originalConfig?.workerTimeoutMs !== undefined
+                    || this.fileConfigScalars?.workerTimeoutMs !== undefined;
+                if (!maxConcurrentExplicit && typeof saved.config?.maxConcurrent === 'number' && saved.config.maxConcurrent > 0) {
                     this.config.maxConcurrent = saved.config.maxConcurrent;
                 }
-                if (typeof saved.config?.workerTimeoutMs === 'number' && saved.config.workerTimeoutMs > 0) {
+                if (!workerTimeoutExplicit && typeof saved.config?.workerTimeoutMs === 'number' && saved.config.workerTimeoutMs > 0) {
                     this.config.workerTimeoutMs = saved.config.workerTimeoutMs;
                 }
                 // Restore worker runtime states (runCount, successCount, etc.)

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.61.1",
+  "version": "3.62.0",
   "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",