claude-flow 3.60.1 → 3.61.0

package/README.md

@@ -16,6 +16,7 @@
 <br>
 <a href="https://github.com/ruvnet/claude-flow"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/d1e80400bdefe01d3b13e70395f88fffab76bb18/docs/assets/readme/badges/claude.svg" width="300" height="76" alt="Claude Code plugin"></a>
 <a href="https://www.npmjs.com/package/@claude-flow/codex"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/d1e80400bdefe01d3b13e70395f88fffab76bb18/docs/assets/readme/badges/codex.svg" width="300" height="76" alt="Codex plugin"></a>
+<a href="https://chatgpt.com/plugins/plugin_asdk_app_6ab674ff53c48191bb37040c343e31f3"><img src="docs/assets/readme/badges/chatgpt.svg" width="300" height="76" alt="ChatGPT plugin: RuFlo Federation"></a>
 </p>
 
 </div>

package/package.json

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

package/v3/@claude-flow/cli/README.md

@@ -16,6 +16,7 @@
 <br>
 <a href="https://github.com/ruvnet/claude-flow"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/d1e80400bdefe01d3b13e70395f88fffab76bb18/docs/assets/readme/badges/claude.svg" width="300" height="76" alt="Claude Code plugin"></a>
 <a href="https://www.npmjs.com/package/@claude-flow/codex"><img src="https://raw.githubusercontent.com/ruvnet/ruflo/d1e80400bdefe01d3b13e70395f88fffab76bb18/docs/assets/readme/badges/codex.svg" width="300" height="76" alt="Codex plugin"></a>
+<a href="https://chatgpt.com/plugins/plugin_asdk_app_6ab674ff53c48191bb37040c343e31f3"><img src="docs/assets/readme/badges/chatgpt.svg" width="300" height="76" alt="ChatGPT plugin: RuFlo Federation"></a>
 </p>
 
 </div>

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

@@ -1,11 +1,11 @@
 {
   "schemaVersion": 1,
   "generation": 7,
-  "generatedAt": "2026-10-23T18:53:29.930Z",
-  "gitSha": "af6c74b3",
+  "generatedAt": "2026-10-24T03:29:19.446Z",
+  "gitSha": "52884d98",
   "catalog": {
     "agents": 177,
-    "tools": 438,
+    "tools": 439,
     "skills": 34
   },
   "benchmark": null

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

@@ -15,6 +15,7 @@ import { gateWithAIDefence } from '../rure/aidefence-gate.js';
 import { parseBinary, extractStrings, MAX_BINARY_BYTES } from '../rure/binary-parse.js';
 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';
 function fail(error) {
     return { content: [{ type: 'text', text: JSON.stringify({ success: false, error }) }], isError: true };
 }
@@ -355,5 +356,57 @@ export const rureTools = [
             }
         },
     },
+    {
+        name: 'rure_analyze_cuda',
+        description: 'Statically inventory the GPU code in a CUDA program (ADR-0006): from a host ELF/PE with a .nv_fatbin section, a standalone fatbin, cubin or PTX file, the fatbin containers and entries (PTX or cubin, target architecture sm_NN, compression: zstd and LZ4 payloads are read under size caps), and per kernel its mangled name, code size, register count, constant/shared/local memory and an instruction estimate; PTX version, target and kernel names. Parses only: no SASS decoding, no CUDA toolkit or driver, nothing is run, and nothing is written. Names from the file are untrusted text and are screened by AIDefence (redactedCount / screened report this). Use when you need the GPU side of a CUDA program (which architectures it targets, whether it ships PTX, which kernels exist and what each costs): rure_analyze_binary alone only shows the .nv_fatbin section names, and grep or strings find kernel names only by chance. Run rure_analyze_binary first when it is not known whether a file holds CUDA code.',
+        category: 'rure',
+        tags: ['reverse-engineering', 'cuda', 'gpu', 'fatbin', 'ptx', 'static-analysis'],
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute path to a CUDA host binary (ELF/PE), a .fatbin, a .cubin or a .ptx file' },
+                includePtx: { type: 'boolean', description: 'Also return the PTX text, cut at 64 KiB (default false)' },
+            },
+            required: ['path'],
+        },
+        handler: async (input) => {
+            const v = validatePath(input.path, 'path');
+            if (!v.valid)
+                return fail(v.error);
+            try {
+                const r = readCapped(v.sanitized, MAX_BINARY_BYTES);
+                if (!r.ok)
+                    return fail(r.error);
+                const info = analyzeCuda(r.bytes, { includePtx: input.includePtx === true });
+                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 kernels = info.kernels.map((k, i) => ({ ...k, name: names[i], identifier: k.identifier === null ? null : idents[i] }));
+                const ptx = [];
+                for (const m of info.ptx) {
+                    const entries = await sc.screen(m.entries.map((e) => e.name));
+                    const functions = await sc.screen(m.functions);
+                    const text = m.text === undefined ? undefined : await sc.one(m.text);
+                    ptx.push({ ...m, entries: m.entries.map((e, i) => ({ ...e, name: entries[i] })), functions, ...(text !== undefined && { text }) });
+                }
+                const hostSignals = await sc.screen(info.hostSignals);
+                const hostSection = info.hostSection === null ? null : { ...info.hostSection, name: await sc.one(info.hostSection.name) };
+                const entryKernels = kernels.filter((k) => k.isEntry).length;
+                return ok({
+                    ...info,
+                    hostSection,
+                    hostSignals,
+                    kernels,
+                    ptx,
+                    summary: { containers: info.containers, entries: info.entries.length, cubins: info.entries.filter((e) => e.kind === 'cubin').length, ptxEntries: info.entries.filter((e) => e.kind === 'ptx').length, kernels: entryKernels, deviceFunctions: kernels.length - entryKernels },
+                    redactedCount: sc.redacted,
+                    screened: sc.screened,
+                });
+            }
+            catch (err) {
+                return fail(`cuda analysis 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

@@ -0,0 +1,36 @@
+/**
+ * ruRE Phase 5 — a cubin (ADR-0006): an ELF64 for the GPU (`e_machine` 190). Read here for its kernels, from the symbol table, which
+ * `parseBinary` does not read. Layout checked against `cuobjdump -symbols` and `-res-usage` on real nvcc output. Bounds-checked
+ * throughout; never throws on hostile input (a failure is a warning and what was read stays).
+ */
+export declare const EM_CUDA = 190;
+export declare const MAX_KERNELS = 500;
+export interface CubinKernel {
+    /** The mangled name as in the symbol table. */
+    name: string;
+    /** The plain identifier of a simple `_Z<len><name>...` name, else null: full demangling is not attempted. */
+    identifier: string | null;
+    /** A kernel (launchable, `STO_CUDA_ENTRY`) or a device function (callable from the GPU only). */
+    isEntry: boolean;
+    codeBytes: number | null;
+    /** codeBytes / 16, for SM 7.0 and later (a SASS instruction is 16 bytes there); null otherwise. An estimate, not a decode. */
+    instructionEstimate: number | null;
+    /** The register count from the global .nv.info section (EIATTR_REGCOUNT: a symbol index and a count); null when no record names this symbol. */
+    registers: number | null;
+    constantBytes: number | null;
+    sharedBytes: number | null;
+    localBytes: number | null;
+}
+export interface CubinInfo {
+    /** SM number from `e_flags` (80 for sm_80), or null. */
+    archFlag: number | null;
+    sectionCount: number;
+    kernels: CubinKernel[];
+    warnings: string[];
+    truncated: boolean;
+}
+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;
+export declare function parseCubin(b: Buffer): CubinInfo;
+//# sourceMappingURL=cuda-cubin.d.ts.map

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

@@ -0,0 +1,148 @@
+/**
+ * ruRE Phase 5 — a cubin (ADR-0006): an ELF64 for the GPU (`e_machine` 190). Read here for its kernels, from the symbol table, which
+ * `parseBinary` does not read. Layout checked against `cuobjdump -symbols` and `-res-usage` on real nvcc output. Bounds-checked
+ * throughout; never throws on hostile input (a failure is a warning and what was read stays).
+ */
+export const EM_CUDA = 190;
+const MAX_SECTIONS = 4096;
+const MAX_SYMBOLS = 2000;
+export const MAX_KERNELS = 500;
+const NAME_MAX = 200;
+const STO_CUDA_ENTRY = 0x10;
+const EIATTR_REGCOUNT = 0x2f;
+const MAX_INFO_RECORDS = 4096;
+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)
+        return '';
+    let stop = at;
+    while (stop < end && stop - at < NAME_MAX && b[stop] !== 0)
+        stop += 1;
+    return b.toString('latin1', at, stop);
+};
+/** The register count per symbol index from the global .nv.info section: records of (format u8, attribute u8, size u16) and a payload. */
+function regCounts(b, offset, size) {
+    const out = new Map();
+    const end = Math.min(b.length, offset + size);
+    let p = offset;
+    for (let n = 0; p + 4 <= end && n < MAX_INFO_RECORDS; n++) {
+        const format = b[p];
+        const attribute = b[p + 1];
+        const length = b.readUInt16LE(p + 2);
+        // Format 4 carries `length` payload bytes; the other formats seen (1, 3) carry nothing after the 4-byte header.
+        if (format === 4) {
+            if (p + 4 + length > end)
+                break;
+            if (attribute === EIATTR_REGCOUNT && length === 8)
+                out.set(b.readUInt32LE(p + 4), b.readUInt32LE(p + 8));
+            p += 4 + length;
+        }
+        else {
+            p += 4;
+        }
+    }
+    return out;
+}
+/** `_Z5saxpyifPKfPf` -> `saxpy`; anything with a namespace, template or other prefix -> null. */
+export function simpleIdentifier(name) {
+    const m = /^_Z(\d{1,3})([A-Za-z_]\w*)$/.exec(name);
+    if (m === null)
+        return null;
+    const length = Number(m[1]);
+    const rest = m[2];
+    return length > 0 && length <= rest.length ? rest.slice(0, length) : null;
+}
+export function parseCubin(b) {
+    const info = { archFlag: null, sectionCount: 0, kernels: [], warnings: [], truncated: false };
+    if (!isCubin(b)) {
+        info.warnings.push('not a CUDA ELF (64-bit little-endian, e_machine 190)');
+        return info;
+    }
+    try {
+        const flags = b.readUInt32LE(0x30);
+        info.archFlag = (flags >>> 8) & 0xff;
+        const shoff = Number(b.readBigUInt64LE(0x28));
+        const entsize = b.readUInt16LE(0x3a);
+        let count = b.readUInt16LE(0x3c);
+        const strIndex = b.readUInt16LE(0x3e);
+        if (entsize !== 64 || shoff <= 0 || shoff + count * 64 > b.length) {
+            info.warnings.push('the section header table is missing or runs past the file');
+            return info;
+        }
+        if (count > MAX_SECTIONS) {
+            count = MAX_SECTIONS;
+            info.truncated = true;
+            info.warnings.push(`more than ${MAX_SECTIONS} sections: the rest are not read`);
+        }
+        info.sectionCount = count;
+        const secs = [];
+        const header = (i) => shoff + i * 64;
+        const strOffset = strIndex < count ? Number(b.readBigUInt64LE(header(strIndex) + 24)) : 0;
+        const strSize = strIndex < count ? Number(b.readBigUInt64LE(header(strIndex) + 32)) : 0;
+        for (let i = 0; i < count; i++) {
+            const h = header(i);
+            secs.push({
+                name: cstr(b, strOffset + b.readUInt32LE(h), Math.min(b.length, strOffset + strSize)),
+                type: b.readUInt32LE(h + 4),
+                offset: Number(b.readBigUInt64LE(h + 24)),
+                size: Number(b.readBigUInt64LE(h + 32)),
+                link: b.readUInt32LE(h + 40),
+                info: b.readUInt32LE(h + 44),
+            });
+        }
+        const sizeOf = new Map();
+        for (const s of secs)
+            if (!sizeOf.has(s.name))
+                sizeOf.set(s.name, s.size);
+        const symtab = secs.find(s => s.type === 2);
+        const globalInfo = secs.find(s => s.name === '.nv.info');
+        const regs = globalInfo !== undefined && globalInfo.offset + globalInfo.size <= b.length ? regCounts(b, globalInfo.offset, globalInfo.size) : new Map();
+        const strtab = symtab === undefined ? undefined : secs[symtab.link];
+        if (symtab === undefined || strtab === undefined) {
+            info.warnings.push('no symbol table: no kernels are listed');
+            return info;
+        }
+        if (symtab.offset + symtab.size > b.length || strtab.offset + strtab.size > b.length) {
+            info.warnings.push('the symbol table runs past the file');
+            return info;
+        }
+        const strEnd = strtab.offset + strtab.size;
+        const total = Math.min(Math.floor(symtab.size / 24), MAX_SYMBOLS);
+        if (Math.floor(symtab.size / 24) > MAX_SYMBOLS) {
+            info.truncated = true;
+            info.warnings.push(`more than ${MAX_SYMBOLS} symbols: the rest are not read`);
+        }
+        for (let i = 0; i < total; i++) {
+            const at = symtab.offset + i * 24;
+            const type = b[at + 4] & 0xf;
+            const bind = b[at + 4] >> 4;
+            if (type !== 2 || bind !== 1)
+                continue;
+            if (info.kernels.length >= MAX_KERNELS) {
+                info.truncated = true;
+                info.warnings.push(`more than ${MAX_KERNELS} functions: the rest are not read`);
+                break;
+            }
+            const name = cstr(b, strtab.offset + b.readUInt32LE(at), strEnd);
+            const sec = secs[b.readUInt16LE(at + 6)];
+            const code = sec !== undefined && sec.name.startsWith('.text.') ? sec : undefined;
+            const archNumber = info.archFlag ?? 0;
+            info.kernels.push({
+                name,
+                identifier: simpleIdentifier(name),
+                isEntry: (b[at + 5] & STO_CUDA_ENTRY) !== 0,
+                codeBytes: code?.size ?? null,
+                instructionEstimate: code !== undefined && archNumber >= 70 ? Math.floor(code.size / 16) : null,
+                registers: regs.get(i) ?? null,
+                constantBytes: sizeOf.get(`.nv.constant0.${name}`) ?? null,
+                sharedBytes: sizeOf.get(`.nv.shared.${name}`) ?? null,
+                localBytes: sizeOf.get(`.nv.local.${name}`) ?? null,
+            });
+        }
+    }
+    catch (err) {
+        info.warnings.push(`cubin parse stopped: ${err instanceof RangeError ? 'out-of-bounds read' : String(err).slice(0, 100)}`);
+    }
+    return info;
+}
+//# sourceMappingURL=cuda-cubin.js.map

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

@@ -0,0 +1,48 @@
+export declare const FATBIN_MAGIC = 3126193488;
+export declare const MAX_CONTAINERS = 64;
+export declare const MAX_ENTRIES = 256;
+/** The most one entry may decompress to, and the most all entries of one file may. */
+export declare const MAX_ENTRY_BYTES: number;
+export declare const MAX_TOTAL_BYTES: number;
+export type Compression = 'none' | 'zstd' | 'lz4' | 'unknown';
+export type Zstd = (input: Buffer, maxOutput: number) => Buffer;
+export declare const defaultZstd: Zstd | null;
+export interface RawEntry {
+    container: number;
+    index: number;
+    kind: number;
+    headerSize: number;
+    paddedSize: number;
+    compressedSize: number;
+    version: number;
+    archNumber: number;
+    objNameOffset: number;
+    objNameLen: number;
+    flags: bigint;
+    decompressedSize: number;
+    /** Where the payload starts in the buffer, and how many bytes of it are really there. */
+    payloadOffset: number;
+    payloadLength: number;
+}
+/** Walks the containers in b[start, end). A malformed header ends the walk with a warning; what was read stays. */
+export declare function walkFatbin(b: Buffer, start: number, end: number, warnings: string[]): {
+    entries: RawEntry[];
+    containers: number;
+    truncated: boolean;
+};
+/**
+ * An LZ4 block (no frame), as CUDA 12 writes. Original: reads only inside `src`, writes only inside `maxOut`, refuses a match offset
+ * that points before the start of the output. Throws RangeError on any malformed input.
+ */
+export declare function lz4Block(src: Buffer, maxOut: number): Buffer;
+export interface Payload {
+    /** The bytes of the cubin or the PTX text, or null when they could not be read (the reason is in `note`). */
+    data: Buffer | null;
+    compressed: Compression;
+    note?: string;
+}
+/** The entry's payload as bytes, decompressed when it is and when it may be. `budget.left` is spent by what each attempt claims, win or lose. */
+export declare function readPayload(b: Buffer, entry: RawEntry, zstd: Zstd | null, budget: {
+    left: number;
+}): Payload;
+//# sourceMappingURL=cuda-fatbin.d.ts.map

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

@@ -0,0 +1,186 @@
+/**
+ * ruRE Phase 5 — the CUDA fatbin container (ADR-0006). A `.nv_fatbin` section is several containers back to back; each is a 16-byte
+ * header (magic 0xBA55ED50, version, header size, payload size) and entries (PTX text or a cubin, possibly compressed). Layout read from
+ * real nvcc output, not from a specification. Parses, never executes; every offset is bounds-checked; decompression is capped twice
+ * (the claimed size is refused first, and the decompressor is handed the cap as its own limit).
+ */
+import * as zlib from 'node:zlib';
+export const FATBIN_MAGIC = 0xba55ed50;
+export const MAX_CONTAINERS = 64;
+export const MAX_ENTRIES = 256;
+/** The most one entry may decompress to, and the most all entries of one file may. */
+export const MAX_ENTRY_BYTES = 16 * 1024 * 1024;
+export const MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+const FLAG_LZ4 = 0x2000n;
+const FLAG_ZSTD = 0x8000n;
+const ZSTD_MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+/**
+ * zstd where this Node has it (22.15 and later); null where it does not, which is said, not hidden. A namespace import and a type check, not a
+ * named import: on Node 20 `zstdDecompressSync` is not an export, and a named import of it would stop the whole module from loading.
+ */
+const zstdFn = zlib.zstdDecompressSync;
+export const defaultZstd = typeof zstdFn === 'function' ? (input, max) => zstdFn(input, { maxOutputLength: max }) : null;
+const num = (v) => (v > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(v));
+/** Walks the containers in b[start, end). A malformed header ends the walk with a warning; what was read stays. */
+export function walkFatbin(b, start, end, warnings) {
+    const entries = [];
+    let containers = 0;
+    let pos = start;
+    let truncated = false;
+    while (pos + 16 <= end && b.readUInt32LE(pos) === FATBIN_MAGIC) {
+        if (containers >= MAX_CONTAINERS) {
+            truncated = true;
+            warnings.push(`more than ${MAX_CONTAINERS} fatbin containers: the rest are not read`);
+            break;
+        }
+        const headerSize = b.readUInt16LE(pos + 6);
+        const claimed = num(b.readBigUInt64LE(pos + 8));
+        if (headerSize < 16 || headerSize > 4096 || pos + headerSize > end) {
+            warnings.push(`container ${containers}: header size ${headerSize} is out of range, the walk stops`);
+            break;
+        }
+        const limit = Math.min(end, pos + headerSize + claimed);
+        if (pos + headerSize + claimed > end)
+            warnings.push(`container ${containers}: its size (${claimed}) runs past the data, read up to the end`);
+        containers += 1;
+        let p = pos + headerSize;
+        while (p + 16 <= limit) {
+            if (entries.length >= MAX_ENTRIES) {
+                truncated = true;
+                warnings.push(`more than ${MAX_ENTRIES} fatbin entries: the rest are not read`);
+                return { entries, containers, truncated };
+            }
+            const size = b.readUInt32LE(p + 4);
+            if (size < 16 || size > 4096 || p + size > limit) {
+                warnings.push(`container ${containers - 1}: an entry header length of ${size} is out of range, this container's walk stops`);
+                break;
+            }
+            const padded = num(b.readBigUInt64LE(p + 8));
+            const full = size >= 64;
+            const payloadOffset = p + size;
+            const payloadLength = Math.max(0, Math.min(padded, limit - payloadOffset));
+            if (!full)
+                warnings.push(`container ${containers - 1}: an entry header of ${size} bytes is shorter than the 64 that carry its fields`);
+            if (padded > limit - payloadOffset)
+                warnings.push(`container ${containers - 1}: an entry claims ${padded} payload bytes, only ${limit - payloadOffset} are there`);
+            entries.push({
+                container: containers - 1,
+                index: entries.length,
+                kind: b.readUInt16LE(p),
+                headerSize: size,
+                paddedSize: padded,
+                compressedSize: full ? b.readUInt32LE(p + 16) : 0,
+                version: full ? b.readUInt32LE(p + 24) : 0,
+                archNumber: full ? b.readUInt32LE(p + 28) : 0,
+                objNameOffset: full ? b.readUInt32LE(p + 32) : 0,
+                objNameLen: full ? b.readUInt32LE(p + 36) : 0,
+                flags: full ? b.readBigUInt64LE(p + 40) : 0n,
+                decompressedSize: full ? num(b.readBigUInt64LE(p + 56)) : 0,
+                payloadOffset,
+                payloadLength,
+            });
+            p += size + padded;
+        }
+        pos = limit;
+    }
+    const rest = b.subarray(pos, end);
+    if (rest.length > 0 && rest.some(byte => byte !== 0))
+        warnings.push(`${rest.length} bytes after the last container are not a fatbin`);
+    return { entries, containers, truncated };
+}
+/**
+ * An LZ4 block (no frame), as CUDA 12 writes. Original: reads only inside `src`, writes only inside `maxOut`, refuses a match offset
+ * that points before the start of the output. Throws RangeError on any malformed input.
+ */
+export function lz4Block(src, maxOut) {
+    const out = Buffer.allocUnsafe(maxOut);
+    let ip = 0;
+    let op = 0;
+    while (ip < src.length) {
+        const token = src[ip++];
+        let literals = token >> 4;
+        if (literals === 15) {
+            let more;
+            do {
+                if (ip >= src.length)
+                    throw new RangeError('literal length runs past the input');
+                more = src[ip++];
+                literals += more;
+                if (literals > maxOut)
+                    throw new RangeError('literal length past the cap');
+            } while (more === 255);
+        }
+        if (ip + literals > src.length)
+            throw new RangeError('literals run past the input');
+        if (op + literals > maxOut)
+            throw new RangeError('output past the cap');
+        src.copy(out, op, ip, ip + literals);
+        ip += literals;
+        op += literals;
+        if (ip >= src.length)
+            break;
+        if (ip + 2 > src.length)
+            throw new RangeError('match offset runs past the input');
+        const offset = src.readUInt16LE(ip);
+        ip += 2;
+        if (offset === 0 || offset > op)
+            throw new RangeError('match offset points before the start of the output');
+        let length = token & 15;
+        if (length === 15) {
+            let more;
+            do {
+                if (ip >= src.length)
+                    throw new RangeError('match length runs past the input');
+                more = src[ip++];
+                length += more;
+                if (length > maxOut)
+                    throw new RangeError('match length past the cap');
+            } while (more === 255);
+        }
+        length += 4;
+        if (op + length > maxOut)
+            throw new RangeError('output past the cap');
+        // Byte by byte: a match may overlap what it is writing (that is how a run is encoded).
+        for (let i = 0; i < length; i++)
+            out[op + i] = out[op - offset + i];
+        op += length;
+    }
+    return out.subarray(0, op);
+}
+/** The entry's payload as bytes, decompressed when it is and when it may be. `budget.left` is spent by what each attempt claims, win or lose. */
+export function readPayload(b, entry, zstd, budget) {
+    const raw = b.subarray(entry.payloadOffset, entry.payloadOffset + entry.payloadLength);
+    const isZstd = (entry.flags & FLAG_ZSTD) !== 0n;
+    const isLz4 = (entry.flags & FLAG_LZ4) !== 0n;
+    if (!isZstd && !isLz4)
+        return { data: raw, compressed: 'none' };
+    if (isZstd && isLz4)
+        return { data: null, compressed: 'unknown', note: 'both the zstd and the lz4 flag are set: not read' };
+    const kind = isZstd ? 'zstd' : 'lz4';
+    const claimed = entry.decompressedSize;
+    if (claimed <= 0)
+        return { data: null, compressed: kind, note: 'the header gives no decompressed size: not read' };
+    if (claimed > MAX_ENTRY_BYTES)
+        return { data: null, compressed: kind, note: `claims ${claimed} bytes decompressed: over the ${MAX_ENTRY_BYTES}-byte cap, not read` };
+    if (claimed > budget.left)
+        return { data: null, compressed: kind, note: 'the total decompression budget for this file is spent: not read' };
+    const packed = raw.subarray(0, entry.compressedSize > 0 ? Math.min(entry.compressedSize, raw.length) : raw.length);
+    if (isZstd) {
+        if (!packed.subarray(0, 4).equals(ZSTD_MAGIC))
+            return { data: null, compressed: 'unknown', note: 'the zstd flag is set but the payload does not start with a zstd frame: not read' };
+        if (zstd === null)
+            return { data: null, compressed: 'zstd', note: 'this Node cannot read zstd (it needs 22.15 or later)' };
+    }
+    // Charged when the attempt starts, not when it succeeds: a stream that fails late must not be retryable by 256 entries for 4 GiB of work.
+    budget.left -= claimed;
+    try {
+        const out = isZstd ? zstd(packed, claimed) : lz4Block(packed, claimed);
+        if (out.length !== claimed)
+            return { data: null, compressed: kind, note: `decompressed to ${out.length} bytes, the header says ${claimed}: not used` };
+        return { data: out, compressed: kind };
+    }
+    catch (err) {
+        return { data: null, compressed: kind, note: `could not be decompressed: ${err instanceof Error ? err.message.slice(0, 120) : 'error'}` };
+    }
+}
+//# sourceMappingURL=cuda-fatbin.js.map

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

@@ -0,0 +1,68 @@
+/**
+ * ruRE Phase 5 — CUDA fatbin and cubin static analysis (ADR-0006). One entry point: `analyzeCuda(bytes)` decides what it was handed from
+ * the bytes (a host ELF or PE with a `.nv_fatbin` section, a standalone fatbin, a standalone cubin, or PTX text), walks the containers,
+ * decompresses what may be decompressed under the caps, and returns the inventory: architectures, PTX, kernels and what each costs.
+ * Parses, never executes; no CUDA toolkit or driver is touched.
+ */
+import { MAX_BINARY_BYTES } from './binary-parse.js';
+import { type Compression, type Zstd } from './cuda-fatbin.js';
+import { type CubinKernel } from './cuda-cubin.js';
+import { type PtxInfo } from './cuda-ptx.js';
+export { MAX_BINARY_BYTES };
+export type CudaSource = 'host' | 'fatbin' | 'cubin' | 'ptx';
+export interface CudaEntry {
+    index: number;
+    container: number;
+    kind: 'ptx' | 'cubin' | 'unknown';
+    rawKind: number;
+    arch: string | null;
+    /** Reported raw: its meaning is not documented. */
+    version: string;
+    flags: string;
+    compressed: Compression;
+    storedBytes: number;
+    /** Bytes after decompression, or null when the payload could not be read. */
+    size: number | null;
+    read: boolean;
+    note?: string;
+    objName?: {
+        offset: number;
+        length: number;
+    };
+}
+export interface CudaKernel extends CubinKernel {
+    /** The index of the entry (cubin) it was read from, and that entry's architecture. */
+    entry: number | null;
+    arch: string | null;
+}
+export interface CudaPtxModule extends PtxInfo {
+    entry: number | null;
+}
+export interface CudaInfo {
+    source: CudaSource;
+    /** Where the fatbin was in a host file. */
+    hostSection: {
+        name: string;
+        offset: number;
+        size: number;
+    } | null;
+    /** Names in a host file that say it uses CUDA: sections, libraries, driver and runtime imports. */
+    hostSignals: string[];
+    containers: number;
+    entries: CudaEntry[];
+    /** Distinct `sm_NN` of the cubins and of the PTX, sorted. */
+    cubinArchs: string[];
+    ptxArchs: string[];
+    kernels: CudaKernel[];
+    ptx: CudaPtxModule[];
+    warnings: string[];
+    truncated: boolean;
+}
+export interface CudaOptions {
+    includePtx?: boolean;
+    /** Overridable so a Node without zstd can be tested; null means "this runtime cannot read zstd". */
+    zstd?: Zstd | null;
+}
+/** What the bytes are and what is in them. Never throws on hostile input: a failure is a warning. */
+export declare function analyzeCuda(b: Buffer, opts?: CudaOptions): CudaInfo;
+//# sourceMappingURL=cuda-parse.d.ts.map

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

@@ -0,0 +1,127 @@
+/**
+ * ruRE Phase 5 — CUDA fatbin and cubin static analysis (ADR-0006). One entry point: `analyzeCuda(bytes)` decides what it was handed from
+ * the bytes (a host ELF or PE with a `.nv_fatbin` section, a standalone fatbin, a standalone cubin, or PTX text), walks the containers,
+ * decompresses what may be decompressed under the caps, and returns the inventory: architectures, PTX, kernels and what each costs.
+ * Parses, never executes; no CUDA toolkit or driver is touched.
+ */
+import { parseBinary, MAX_BINARY_BYTES } from './binary-parse.js';
+import { defaultZstd, FATBIN_MAGIC, MAX_TOTAL_BYTES, readPayload, walkFatbin } from './cuda-fatbin.js';
+import { isCubin, parseCubin } from './cuda-cubin.js';
+import { looksLikePtx, scanPtx } from './cuda-ptx.js';
+export { MAX_BINARY_BYTES };
+const FATBIN_SECTIONS = new Set(['.nv_fatbin', '.nv_fatb', '__nv_fatbin']);
+const SIGNAL_SECTION = /^(?:\.nv|__nv|\.nvFatBin)/;
+const SIGNAL_LIBRARY = /cuda|cudart|cublas|cudnn|cufft|curand|cusparse|nvrtc|nvcuda|nvml/i;
+const SIGNAL_IMPORT = /^(?:cu[A-Z]\w*|__cuda\w+|__cudaRegister\w+)$/;
+const SIGNAL_MAX = 24;
+const archOf = (n) => (n > 0 && n < 1000 ? `sm_${n}` : null);
+const kindName = (k) => (k === 1 ? 'ptx' : k === 2 ? 'cubin' : 'unknown');
+const empty = (source) => ({ source, hostSection: null, hostSignals: [], containers: 0, entries: [], cubinArchs: [], ptxArchs: [], kernels: [], ptx: [], warnings: [], truncated: false });
+/** Reads the entries of one or more fatbin containers found in b[start, end) and fills `info`. */
+function readFatbin(b, start, end, info, opts) {
+    const zstd = opts.zstd === undefined ? defaultZstd : opts.zstd;
+    const budget = { left: MAX_TOTAL_BYTES };
+    const walked = walkFatbin(b, start, end, info.warnings);
+    info.containers = walked.containers;
+    info.truncated = info.truncated || walked.truncated;
+    if (walked.containers === 0)
+        info.warnings.push('no fatbin container (magic 0xBA55ED50) at the start of the section');
+    for (const raw of walked.entries)
+        info.entries.push(readEntry(b, raw, zstd, budget, info, opts));
+    const archs = (kind) => [...new Set(info.entries.filter(e => e.kind === kind && e.arch !== null).map(e => e.arch))].sort();
+    info.cubinArchs = archs('cubin');
+    info.ptxArchs = archs('ptx');
+}
+function readEntry(b, raw, zstd, budget, info, opts) {
+    const kind = kindName(raw.kind);
+    const payload = readPayload(b, raw, zstd, budget);
+    const arch = archOf(raw.archNumber);
+    const entry = {
+        index: raw.index,
+        container: raw.container,
+        kind,
+        rawKind: raw.kind,
+        arch,
+        version: `0x${raw.version.toString(16)}`,
+        flags: `0x${raw.flags.toString(16)}`,
+        compressed: payload.compressed,
+        storedBytes: raw.compressedSize > 0 ? raw.compressedSize : raw.payloadLength,
+        size: payload.data === null ? null : payload.data.length,
+        read: payload.data !== null,
+        ...(payload.note !== undefined && { note: payload.note }),
+        ...(raw.objNameOffset !== 0 || raw.objNameLen !== 0 ? { objName: { offset: raw.objNameOffset, length: raw.objNameLen } } : {}),
+    };
+    if (payload.data === null)
+        return entry;
+    if (kind === 'cubin') {
+        if (!isCubin(payload.data)) {
+            entry.read = false;
+            entry.note = 'a cubin entry whose payload is not a CUDA ELF: not read';
+            return entry;
+        }
+        const cubin = parseCubin(payload.data);
+        info.warnings.push(...cubin.warnings.map(w => `entry ${raw.index}: ${w}`));
+        info.truncated = info.truncated || cubin.truncated;
+        if (arch !== null && cubin.archFlag !== null && cubin.archFlag !== 0 && cubin.archFlag !== raw.archNumber) {
+            info.warnings.push(`entry ${raw.index}: the entry header says ${arch}, the cubin's e_flags say sm_${cubin.archFlag}`);
+        }
+        for (const k of cubin.kernels)
+            info.kernels.push({ ...k, entry: raw.index, arch });
+    }
+    else if (kind === 'ptx') {
+        const text = payload.data.toString('latin1').replace(/\0+$/, '');
+        info.ptx.push({ ...scanPtx(text, opts.includePtx === true), entry: raw.index });
+    }
+    return entry;
+}
+/** Names in a host binary that say it is a CUDA program (never anything but its own names; nothing is loaded). */
+function hostSignalsOf(host) {
+    const out = [
+        ...host.sections.map(s => s.name).filter(n => SIGNAL_SECTION.test(n)),
+        ...host.libraries.filter(n => SIGNAL_LIBRARY.test(n)),
+        ...host.imports.filter(n => SIGNAL_IMPORT.test(n)).slice(0, 12),
+    ];
+    return [...new Set(out)].slice(0, SIGNAL_MAX);
+}
+/** What the bytes are and what is in them. Never throws on hostile input: a failure is a warning. */
+export function analyzeCuda(b, opts = {}) {
+    if (b.length >= 4 && b.readUInt32LE(0) === FATBIN_MAGIC) {
+        const info = empty('fatbin');
+        readFatbin(b, 0, b.length, info, opts);
+        return info;
+    }
+    if (isCubin(b)) {
+        const info = empty('cubin');
+        const cubin = parseCubin(b);
+        const arch = cubin.archFlag === null ? null : archOf(cubin.archFlag);
+        info.warnings.push(...cubin.warnings);
+        info.truncated = cubin.truncated;
+        info.kernels = cubin.kernels.map(k => ({ ...k, entry: null, arch }));
+        info.cubinArchs = arch === null ? [] : [arch];
+        return info;
+    }
+    if (looksLikePtx(b)) {
+        const info = empty('ptx');
+        const ptx = scanPtx(b.toString('latin1'), opts.includePtx === true);
+        info.ptx = [{ ...ptx, entry: null }];
+        info.ptxArchs = ptx.target === null ? [] : [ptx.target];
+        return info;
+    }
+    const info = empty('host');
+    const host = parseBinary(b);
+    info.warnings.push(...host.warnings);
+    info.hostSignals = hostSignalsOf(host);
+    const section = host.sections.find(s => FATBIN_SECTIONS.has(s.name));
+    if (section === undefined) {
+        info.warnings.push(`no .nv_fatbin section: this does not look like a CUDA program (format ${host.format})`);
+        return info;
+    }
+    info.hostSection = { name: section.name, offset: section.offset, size: section.size };
+    if (section.offset < 0 || section.size <= 0 || section.offset + section.size > b.length) {
+        info.warnings.push('the .nv_fatbin section runs past the file: not read');
+        return info;
+    }
+    readFatbin(b, section.offset, section.offset + section.size, info, opts);
+    return info;
+}
+//# sourceMappingURL=cuda-parse.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * ruRE Phase 5 — PTX text (ADR-0006): NVIDIA's virtual ISA. Only a bounded scan for the header directives and the kernel and function
+ * names; the text is never interpreted further and never run. The scan reads at most 4 MiB, and every pattern is linear.
+ */
+export declare const MAX_PTX_SCAN: number;
+export declare const MAX_PTX_TEXT: number;
+export interface PtxInfo {
+    version: string | null;
+    target: string | null;
+    addressSize: number | null;
+    /** `.entry` kernels with the number of `.param` declarations in their signature. */
+    entries: {
+        name: string;
+        params: number;
+    }[];
+    /** `.func` device functions. */
+    functions: string[];
+    /** The text itself, only when asked for, cut at MAX_PTX_TEXT. */
+    text?: string;
+    textTruncated?: boolean;
+    scanTruncated: boolean;
+}
+/**
+ * True when the bytes look like PTX source: the first directive is `.version` after comments and blank space. A hand-written scan, not a
+ * regex: a lazy comment pattern inside a repeated group backtracks exponentially on `/*` followed by many `*` + `/` pairs (CodeQL js/redos
+ * caught the first version of this). Every step here moves forward, so the cost is linear in the 8 KiB it looks at.
+ */
+export declare function looksLikePtx(b: Buffer): boolean;
+export declare function scanPtx(text: string, includeText: boolean): PtxInfo;
+//# sourceMappingURL=cuda-ptx.d.ts.map

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

@@ -0,0 +1,67 @@
+/**
+ * ruRE Phase 5 — PTX text (ADR-0006): NVIDIA's virtual ISA. Only a bounded scan for the header directives and the kernel and function
+ * names; the text is never interpreted further and never run. The scan reads at most 4 MiB, and every pattern is linear.
+ */
+export const MAX_PTX_SCAN = 4 * 1024 * 1024;
+export const MAX_PTX_TEXT = 64 * 1024;
+const MAX_NAMES = 500;
+const NAME_MAX = 200;
+/**
+ * True when the bytes look like PTX source: the first directive is `.version` after comments and blank space. A hand-written scan, not a
+ * regex: a lazy comment pattern inside a repeated group backtracks exponentially on `/*` followed by many `*` + `/` pairs (CodeQL js/redos
+ * caught the first version of this). Every step here moves forward, so the cost is linear in the 8 KiB it looks at.
+ */
+export function looksLikePtx(b) {
+    const head = b.toString('latin1', 0, Math.min(b.length, 8192));
+    let i = 0;
+    for (;;) {
+        while (i < head.length && (head.charCodeAt(i) <= 32 || head.charCodeAt(i) === 0xa0))
+            i += 1;
+        if (head.startsWith('//', i)) {
+            const end = head.indexOf('\n', i);
+            if (end < 0)
+                return false;
+            i = end + 1;
+        }
+        else if (head.startsWith('/*', i)) {
+            const end = head.indexOf('*/', i + 2);
+            if (end < 0)
+                return false;
+            i = end + 2;
+        }
+        else
+            break;
+    }
+    return /^\.version\s+\d/.test(head.slice(i, i + 32));
+}
+export function scanPtx(text, includeText) {
+    const scanned = text.length > MAX_PTX_SCAN ? text.slice(0, MAX_PTX_SCAN) : text;
+    const info = {
+        // Space and tab only, never `\s`, at a line start: `\s` also matches newlines, so every line start inside a run of blank lines rescanned the
+        // rest of the run (80000 blank lines took 4.6 s and 320000 took 71 s before this).
+        version: /^[ \t]*\.version[ \t]+(\d+\.\d+)/m.exec(scanned)?.[1] ?? null,
+        target: /^[ \t]*\.target[ \t]+([A-Za-z0-9_., ]{1,60}?)[ \t]*(?:\/\/|$)/m.exec(scanned)?.[1]?.trim() ?? null,
+        addressSize: Number(/^[ \t]*\.address_size[ \t]+(\d+)/m.exec(scanned)?.[1] ?? NaN) || null,
+        entries: [],
+        functions: [],
+        scanTruncated: text.length > MAX_PTX_SCAN,
+    };
+    const re = /\.(entry|func)\s{1,64}(?:\([^)]{0,200}\)\s{0,64})?([A-Za-z_$%][\w$.%]{0,198})\s{0,64}\(/g;
+    let m;
+    while ((m = re.exec(scanned)) !== null && info.entries.length + info.functions.length < MAX_NAMES) {
+        const name = m[2].slice(0, NAME_MAX);
+        if (m[1] === 'func') {
+            info.functions.push(name);
+            continue;
+        }
+        const close = scanned.indexOf(')', re.lastIndex);
+        const signature = scanned.slice(re.lastIndex, close < 0 || close - re.lastIndex > 4096 ? re.lastIndex + 4096 : close);
+        info.entries.push({ name, params: (signature.match(/\.param\b/g) ?? []).length });
+    }
+    if (includeText) {
+        info.text = scanned.length > MAX_PTX_TEXT ? scanned.slice(0, MAX_PTX_TEXT) : scanned;
+        info.textTruncated = scanned.length > MAX_PTX_TEXT;
+    }
+    return info;
+}
+//# sourceMappingURL=cuda-ptx.js.map

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

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