claude-flow 3.61.1 → 3.63.0

package/v3/@claude-flow/cli/dist/src/mcp-tools/managed-learning-tool.js

@@ -0,0 +1,46 @@
+/** Learning MCP boundary, kept separate from provider transport and native workers. */
+import { getProjectCwd } from './types.js';
+export const managedLearningTool = {
+    inputSchema: { type: 'object', properties: {
+            action: { type: 'string', enum: ['status', 'record', 'recommend', 'evaluate', 'index', 'recall', 'cycle'] },
+            evidence: { type: 'object', description: 'Closed version1 observation and optional host signature; caller trust labels rejected' },
+            scope: { type: 'object', description: 'Exact taskType, policyHash and evaluatorHash cohort' },
+            manifest: { type: 'object', description: 'Frozen unique heldout taskHashes and at least three trials' },
+            cycle: { type: 'object', description: 'Closed scope/evidence batch, optional index, maxP95Ms and evaluation; no commands, keys or promotion flags' },
+            baselineId: { type: 'string' }, candidateId: { type: 'string' }, id: { type: 'string' }, maxP95Ms: { type: 'number' },
+        }, required: ['action'] },
+    handler: async (input) => {
+        if (input.action !== 'status' && process.env.RUFLO_MANAGED_LEARNING !== '1')
+            return { success: false, error: 'Managed learning writes require host RUFLO_MANAGED_LEARNING=1' };
+        const root = getProjectCwd(), key = process.env.RUFLO_MANAGED_VERIFIER_PUBLIC_KEY;
+        const authorize = () => process.env.RUFLO_MANAGED_LEARNING === '1' && process.env.RUFLO_MANAGED_VERIFIER_PUBLIC_KEY === key && getProjectCwd() === root;
+        try {
+            const learning = await import('../services/managed-learning-store.js');
+            if (input.action !== 'status' && !authorize())
+                throw new Error('Host learning policy changed');
+            if (input.action === 'cycle') {
+                if (Object.keys(input).some(k => !['action', 'cycle'].includes(k)))
+                    throw new Error('Invalid cycle envelope');
+                const { cycleLearning } = await import('../services/managed-learning-loop.js');
+                return { success: true, ...await cycleLearning(root, input.cycle, key, authorize) };
+            }
+            if (input.action === 'status')
+                return { success: true, ...learning.learningStatus(root, key) };
+            if (input.action === 'record')
+                return { success: true, ...learning.recordLearning(root, input.evidence, key) };
+            if (input.action === 'recommend')
+                return { success: true, ...learning.recommendLearning(root, input.scope, key, input.maxP95Ms) };
+            if (input.action === 'evaluate')
+                return { success: true, ...learning.evaluateLearning(root, { scope: input.scope, manifest: input.manifest, baselineId: String(input.baselineId ?? ''), candidateId: String(input.candidateId ?? '') }, key) };
+            if (input.action === 'recall')
+                return { success: true, ...await learning.recallLearning(root, input.scope, key, authorize) };
+            if (input.action === 'index')
+                return { success: true, ...await learning.indexLearning(root, String(input.id ?? ''), key, authorize) };
+            return { success: false, error: 'Unknown managed learning action' };
+        }
+        catch {
+            return { success: false, error: 'Managed learning failed: validate metadata, verifier and store; state may persist, inspect status before retrying; no default changed' };
+        }
+    },
+};
+//# sourceMappingURL=managed-learning-tool.js.map

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

@@ -1466,13 +1466,16 @@ export const memoryTools = [
                 }
                 catch { /* namespace may not exist */ }
             }
-            // Sort by score, deduplicate by key, take top N
+            // Sort by score, deduplicate by (namespace, key), take top N. An entry is
+            // identified by both (see #2271), so the same key in another namespace is
+            // a different entry and must not be dropped as a duplicate.
             allResults.sort((a, b) => b.score - a.score);
             const seen = new Set();
             const deduplicated = allResults.filter(r => {
-                if (seen.has(r.key))
+                const id = JSON.stringify([r.namespace, r.key]);
+                if (seen.has(id))
                     return false;
-                seen.add(r.key);
+                seen.add(id);
                 return true;
             }).slice(0, limit);
             return {

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/missions/schemas.d.ts

@@ -77,6 +77,10 @@ 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: {
         revision: number;
         digest: string;
@@ -92,10 +96,6 @@ export declare const missionRecordSchema: z.ZodObject<{
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
     evidenceRefs: string[];
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     lastEventSequence: number;
     authorizationRef?: string | undefined;
 }, {
@@ -103,6 +103,10 @@ 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: {
         revision: number;
         digest: string;
@@ -118,10 +122,6 @@ export declare const missionRecordSchema: z.ZodObject<{
     budgetRef: string;
     executionMode: "durable-executor" | "session-bound";
     evidenceRefs: string[];
-    acceptance: {
-        revision: number;
-        criteriaDigest: string;
-    };
     lastEventSequence: number;
     authorizationRef?: string | undefined;
 }>;
@@ -397,11 +397,11 @@ export declare const createInputSchema: z.ZodObject<{
     requestId: z.ZodString;
     objective: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    objective: string;
     requestId: string;
-}, {
     objective: string;
+}, {
     requestId: string;
+    objective: string;
 }>;
 export declare const planInputSchema: z.ZodObject<{
     requestId: z.ZodString;
@@ -580,6 +580,7 @@ export declare const planInputSchema: z.ZodObject<{
         } | undefined;
     }>;
 }, "strict", z.ZodTypeAny, {
+    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -616,10 +617,10 @@ export declare const planInputSchema: z.ZodObject<{
             baseline?: string | undefined;
         }[];
     };
-    requestId: string;
     missionId: string;
     expectedRevision: number;
 }, {
+    requestId: string;
     plan: {
         tasks: {
             id: string;
@@ -656,7 +657,6 @@ export declare const planInputSchema: z.ZodObject<{
             capabilities?: string[] | undefined;
         } | undefined;
     };
-    requestId: string;
     missionId: string;
     expectedRevision: number;
 }>;

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