claude-flow 3.76.1 → 3.77.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude/proven-config.json +1 -1
- package/package.json +1 -1
- package/v3/@claude-flow/cli/dist/src/appliance/rvfa-builder.js +5 -1
- package/v3/@claude-flow/cli/dist/src/commands/analyze.js +15 -1
- package/v3/@claude-flow/cli/dist/src/commands/neural-wsp.d.ts +15 -0
- package/v3/@claude-flow/cli/dist/src/commands/neural-wsp.js +265 -0
- package/v3/@claude-flow/cli/dist/src/commands/neural.js +2 -1
- package/v3/@claude-flow/cli/dist/src/commands/security.js +1 -1
- package/v3/@claude-flow/cli/dist/src/memory/memory-bridge.js +29 -4
- package/v3/@claude-flow/cli/dist/src/missions/schemas.d.ts +38 -38
- package/v3/@claude-flow/cli/dist/src/mods/command-registry/schema.d.ts +210 -210
- package/v3/@claude-flow/cli/dist/src/ruvector/ruv-fann-wsp.d.ts +129 -0
- package/v3/@claude-flow/cli/dist/src/ruvector/ruv-fann-wsp.js +221 -0
- package/v3/@claude-flow/cli/package.json +7 -4
- package/v3/@claude-flow/guidance/package.json +1 -1
|
@@ -0,0 +1,129 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* ruv-fann-wsp.ts — optional ruv-FANN weight-space tooling (ADR-528).
|
|
3
|
+
*
|
|
4
|
+
* Wraps three exact-pinned optional dependencies:
|
|
5
|
+
* - `ruv-fann-wsp` fingerprint, inspect, sensitivity
|
|
6
|
+
* - `ruv-fann-wsp-invariants` finite-domain output-bound checks
|
|
7
|
+
* - `ruv-fann-wsp-lifecycle` bounded-patch regression gates
|
|
8
|
+
*
|
|
9
|
+
* They share the `ruv-fann` core and `ruv-fann-wasm` runtime that agentdb and
|
|
10
|
+
* @metaharness/darwin already install, so they add no native code and no
|
|
11
|
+
* install scripts. The `ruv-fann` 0.3.0 facade is deliberately NOT used: it
|
|
12
|
+
* pulls esbuild (an install script) and a native RVF binding into every
|
|
13
|
+
* install for capabilities ruflo does not call.
|
|
14
|
+
*
|
|
15
|
+
* Every entry point loads the packages lazily. When they are absent the
|
|
16
|
+
* caller gets `{ available: false, reason }`; nothing else in the CLI
|
|
17
|
+
* imports this module, so cold start and routing are unchanged.
|
|
18
|
+
*
|
|
19
|
+
* Results are hash-bound evidence, not authority: nothing here promotes,
|
|
20
|
+
* writes or reroutes on its own.
|
|
21
|
+
*
|
|
22
|
+
* @module ruv-fann-wsp
|
|
23
|
+
*/
|
|
24
|
+
import type { CentroidArtifact } from './centroid-router.js';
|
|
25
|
+
export declare const WSP_PACKAGES: readonly ["ruv-fann-wsp", "ruv-fann-wsp-invariants", "ruv-fann-wsp-lifecycle"];
|
|
26
|
+
export type WspPackage = (typeof WSP_PACKAGES)[number];
|
|
27
|
+
/** Upper bound for any JSON file this module reads (models, suites, patches). */
|
|
28
|
+
export declare const MAX_INPUT_BYTES: number;
|
|
29
|
+
/** INVARIANT_LIMITS.maxCases in ruv-fann-wsp-invariants 0.1.0. */
|
|
30
|
+
export declare const MAX_CASES_PER_SUITE = 16;
|
|
31
|
+
/** Centroids are stored rounded, so a centroid scores slightly below 1 against itself. */
|
|
32
|
+
export declare const SELF_SCORE_TOLERANCE = 0.00001;
|
|
33
|
+
export interface DenseLayer {
|
|
34
|
+
inputs: number;
|
|
35
|
+
outputs: number;
|
|
36
|
+
/** Row-major [outputs, inputs]. */
|
|
37
|
+
weights: number[];
|
|
38
|
+
bias?: number[] | null;
|
|
39
|
+
activation: string;
|
|
40
|
+
steepness: number;
|
|
41
|
+
}
|
|
42
|
+
export interface DenseModel {
|
|
43
|
+
schema: 'ruv-fann.dense-layers/1';
|
|
44
|
+
layers: DenseLayer[];
|
|
45
|
+
}
|
|
46
|
+
export interface InvariantCase {
|
|
47
|
+
name: string;
|
|
48
|
+
inputs: number[];
|
|
49
|
+
rows: number;
|
|
50
|
+
minimum?: number[];
|
|
51
|
+
maximum?: number[];
|
|
52
|
+
expected?: number[];
|
|
53
|
+
tolerance?: number;
|
|
54
|
+
}
|
|
55
|
+
export interface InvariantSuite {
|
|
56
|
+
schema: 'ruv-fann.invariants/1';
|
|
57
|
+
cases: InvariantCase[];
|
|
58
|
+
}
|
|
59
|
+
export interface WspModules {
|
|
60
|
+
wsp: Record<string, any>;
|
|
61
|
+
invariants: Record<string, any>;
|
|
62
|
+
lifecycle: Record<string, any>;
|
|
63
|
+
}
|
|
64
|
+
export type WspLoad = {
|
|
65
|
+
available: true;
|
|
66
|
+
modules: WspModules;
|
|
67
|
+
} | {
|
|
68
|
+
available: false;
|
|
69
|
+
reason: string;
|
|
70
|
+
};
|
|
71
|
+
export type Importer = (specifier: string) => Promise<Record<string, any>>;
|
|
72
|
+
/** Load all three packages once. Never throws. */
|
|
73
|
+
export declare function loadWsp(importer?: Importer): Promise<WspLoad>;
|
|
74
|
+
/**
|
|
75
|
+
* Installed version of each package, or null. `ruv-fann` is not a direct
|
|
76
|
+
* dependency, so it is looked up where ruv-fann-wsp resolves it: nested
|
|
77
|
+
* under it (pnpm, npm conflicts) or beside it (flat npm).
|
|
78
|
+
*/
|
|
79
|
+
export declare function wspVersions(): Record<WspPackage | 'ruv-fann', string | null>;
|
|
80
|
+
/**
|
|
81
|
+
* The centroid router as a one-layer Linear ruv-FANN model. Output k is the
|
|
82
|
+
* dot product with centroid k, which is the router's cosine score for a
|
|
83
|
+
* unit-length query, so the model ranks labels exactly as `classify` does.
|
|
84
|
+
*/
|
|
85
|
+
export declare function centroidToDenseModel(artifact: CentroidArtifact): DenseModel;
|
|
86
|
+
/**
|
|
87
|
+
* Self-routing invariants: fed its own centroid, each label must score
|
|
88
|
+
* 1 ± tolerance and every other label at most `1 - minGap`. A failure means
|
|
89
|
+
* two labels are (near-)duplicates or the artifact is corrupt — the router
|
|
90
|
+
* could not separate them even on their own means.
|
|
91
|
+
*
|
|
92
|
+
* Returned as several suites when there are more labels than one suite allows.
|
|
93
|
+
*/
|
|
94
|
+
export declare function centroidSelfRoutingSuites(artifact: CentroidArtifact, opts?: {
|
|
95
|
+
tolerance?: number;
|
|
96
|
+
minGap?: number;
|
|
97
|
+
}): InvariantSuite[];
|
|
98
|
+
/**
|
|
99
|
+
* Read a JSON file the user named. Refuses non-regular files (FIFOs, devices,
|
|
100
|
+
* directories), symlinks that leave nothing to read, and anything larger
|
|
101
|
+
* than MAX_INPUT_BYTES, before reading it into memory.
|
|
102
|
+
*/
|
|
103
|
+
export declare function readJsonInput(path: string, what: string, maxBytes?: number): unknown;
|
|
104
|
+
/** Shape check before handing a user model to WSP (which validates fully). */
|
|
105
|
+
export declare function assertDenseModel(x: unknown, what?: string): DenseModel;
|
|
106
|
+
export interface SelfRoutingResult {
|
|
107
|
+
accepted: boolean;
|
|
108
|
+
modelHash: string;
|
|
109
|
+
labels: number;
|
|
110
|
+
suites: number;
|
|
111
|
+
checks: number;
|
|
112
|
+
violations: Array<{
|
|
113
|
+
case: string;
|
|
114
|
+
output: string;
|
|
115
|
+
constraint: string;
|
|
116
|
+
actual: number;
|
|
117
|
+
bound: number;
|
|
118
|
+
}>;
|
|
119
|
+
backend: string;
|
|
120
|
+
ms: number;
|
|
121
|
+
}
|
|
122
|
+
/** Run the self-routing invariants against a centroid artifact. */
|
|
123
|
+
export declare function checkCentroidSelfRouting(mods: WspModules, artifact: CentroidArtifact, opts?: {
|
|
124
|
+
tolerance?: number;
|
|
125
|
+
minGap?: number;
|
|
126
|
+
}): Promise<SelfRoutingResult>;
|
|
127
|
+
/** Test hook. */
|
|
128
|
+
export declare function __resetWspForTests(): void;
|
|
129
|
+
//# sourceMappingURL=ruv-fann-wsp.d.ts.map
|
|
@@ -0,0 +1,221 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* ruv-fann-wsp.ts — optional ruv-FANN weight-space tooling (ADR-528).
|
|
3
|
+
*
|
|
4
|
+
* Wraps three exact-pinned optional dependencies:
|
|
5
|
+
* - `ruv-fann-wsp` fingerprint, inspect, sensitivity
|
|
6
|
+
* - `ruv-fann-wsp-invariants` finite-domain output-bound checks
|
|
7
|
+
* - `ruv-fann-wsp-lifecycle` bounded-patch regression gates
|
|
8
|
+
*
|
|
9
|
+
* They share the `ruv-fann` core and `ruv-fann-wasm` runtime that agentdb and
|
|
10
|
+
* @metaharness/darwin already install, so they add no native code and no
|
|
11
|
+
* install scripts. The `ruv-fann` 0.3.0 facade is deliberately NOT used: it
|
|
12
|
+
* pulls esbuild (an install script) and a native RVF binding into every
|
|
13
|
+
* install for capabilities ruflo does not call.
|
|
14
|
+
*
|
|
15
|
+
* Every entry point loads the packages lazily. When they are absent the
|
|
16
|
+
* caller gets `{ available: false, reason }`; nothing else in the CLI
|
|
17
|
+
* imports this module, so cold start and routing are unchanged.
|
|
18
|
+
*
|
|
19
|
+
* Results are hash-bound evidence, not authority: nothing here promotes,
|
|
20
|
+
* writes or reroutes on its own.
|
|
21
|
+
*
|
|
22
|
+
* @module ruv-fann-wsp
|
|
23
|
+
*/
|
|
24
|
+
import { lstatSync, readFileSync, realpathSync } from 'node:fs';
|
|
25
|
+
import { dirname, resolve as resolvePath } from 'node:path';
|
|
26
|
+
import { fileURLToPath } from 'node:url';
|
|
27
|
+
export const WSP_PACKAGES = ['ruv-fann-wsp', 'ruv-fann-wsp-invariants', 'ruv-fann-wsp-lifecycle'];
|
|
28
|
+
/** Upper bound for any JSON file this module reads (models, suites, patches). */
|
|
29
|
+
export const MAX_INPUT_BYTES = 2 * 1024 * 1024;
|
|
30
|
+
/** INVARIANT_LIMITS.maxCases in ruv-fann-wsp-invariants 0.1.0. */
|
|
31
|
+
export const MAX_CASES_PER_SUITE = 16;
|
|
32
|
+
/** Centroids are stored rounded, so a centroid scores slightly below 1 against itself. */
|
|
33
|
+
export const SELF_SCORE_TOLERANCE = 1e-5;
|
|
34
|
+
// A non-literal specifier keeps tsc from resolving the optional packages at
|
|
35
|
+
// build time; they are ESM-only, so `require` cannot load them.
|
|
36
|
+
const defaultImporter = (specifier) => import(specifier);
|
|
37
|
+
let _load = null;
|
|
38
|
+
function isMissingModule(err) {
|
|
39
|
+
const code = err?.code;
|
|
40
|
+
return code === 'ERR_MODULE_NOT_FOUND' || code === 'MODULE_NOT_FOUND';
|
|
41
|
+
}
|
|
42
|
+
/** Load all three packages once. Never throws. */
|
|
43
|
+
export function loadWsp(importer = defaultImporter) {
|
|
44
|
+
if (importer !== defaultImporter)
|
|
45
|
+
return doLoad(importer);
|
|
46
|
+
if (!_load)
|
|
47
|
+
_load = doLoad(importer);
|
|
48
|
+
return _load;
|
|
49
|
+
}
|
|
50
|
+
async function doLoad(importer) {
|
|
51
|
+
const mods = {};
|
|
52
|
+
for (const name of WSP_PACKAGES) {
|
|
53
|
+
try {
|
|
54
|
+
mods[name] = await importer(name);
|
|
55
|
+
}
|
|
56
|
+
catch (err) {
|
|
57
|
+
const why = isMissingModule(err) ? 'is not installed' : `failed to load: ${err instanceof Error ? err.message : String(err)}`;
|
|
58
|
+
return { available: false, reason: `${name} ${why} (optional dependency of @claude-flow/cli)` };
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
return {
|
|
62
|
+
available: true,
|
|
63
|
+
modules: { wsp: mods['ruv-fann-wsp'], invariants: mods['ruv-fann-wsp-invariants'], lifecycle: mods['ruv-fann-wsp-lifecycle'] },
|
|
64
|
+
};
|
|
65
|
+
}
|
|
66
|
+
/** Package root of `name` at or above `dir`, or null. */
|
|
67
|
+
function packageRootAbove(dir, name) {
|
|
68
|
+
for (let i = 0; i < 4; i++) {
|
|
69
|
+
try {
|
|
70
|
+
const pkg = JSON.parse(readFileSync(resolvePath(dir, 'package.json'), 'utf8'));
|
|
71
|
+
if (pkg && pkg.name === name && typeof pkg.version === 'string')
|
|
72
|
+
return { root: dir, version: pkg.version };
|
|
73
|
+
}
|
|
74
|
+
catch { /* keep walking */ }
|
|
75
|
+
dir = dirname(dir);
|
|
76
|
+
}
|
|
77
|
+
return null;
|
|
78
|
+
}
|
|
79
|
+
/**
|
|
80
|
+
* Installed version of each package, or null. `ruv-fann` is not a direct
|
|
81
|
+
* dependency, so it is looked up where ruv-fann-wsp resolves it: nested
|
|
82
|
+
* under it (pnpm, npm conflicts) or beside it (flat npm).
|
|
83
|
+
*/
|
|
84
|
+
export function wspVersions() {
|
|
85
|
+
const out = {};
|
|
86
|
+
let wspRoot = null;
|
|
87
|
+
for (const name of WSP_PACKAGES) {
|
|
88
|
+
out[name] = null;
|
|
89
|
+
try {
|
|
90
|
+
const found = packageRootAbove(dirname(fileURLToPath(import.meta.resolve(name))), name);
|
|
91
|
+
if (found) {
|
|
92
|
+
out[name] = found.version;
|
|
93
|
+
if (name === 'ruv-fann-wsp')
|
|
94
|
+
wspRoot = found.root;
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
catch { /* not installed */ }
|
|
98
|
+
}
|
|
99
|
+
out['ruv-fann'] = null;
|
|
100
|
+
if (wspRoot) {
|
|
101
|
+
for (const dir of [resolvePath(wspRoot, 'node_modules', 'ruv-fann'), resolvePath(wspRoot, '..', 'ruv-fann')]) {
|
|
102
|
+
const found = packageRootAbove(dir, 'ruv-fann');
|
|
103
|
+
if (found && found.root === dir) {
|
|
104
|
+
out['ruv-fann'] = found.version;
|
|
105
|
+
break;
|
|
106
|
+
}
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
return out;
|
|
110
|
+
}
|
|
111
|
+
/**
|
|
112
|
+
* The centroid router as a one-layer Linear ruv-FANN model. Output k is the
|
|
113
|
+
* dot product with centroid k, which is the router's cosine score for a
|
|
114
|
+
* unit-length query, so the model ranks labels exactly as `classify` does.
|
|
115
|
+
*/
|
|
116
|
+
export function centroidToDenseModel(artifact) {
|
|
117
|
+
const weights = [];
|
|
118
|
+
for (const c of artifact.centroids)
|
|
119
|
+
for (const v of c)
|
|
120
|
+
weights.push(v);
|
|
121
|
+
return {
|
|
122
|
+
schema: 'ruv-fann.dense-layers/1',
|
|
123
|
+
layers: [{
|
|
124
|
+
inputs: artifact.dim,
|
|
125
|
+
outputs: artifact.labels.length,
|
|
126
|
+
weights,
|
|
127
|
+
bias: new Array(artifact.labels.length).fill(0),
|
|
128
|
+
activation: 'Linear',
|
|
129
|
+
steepness: 1,
|
|
130
|
+
}],
|
|
131
|
+
};
|
|
132
|
+
}
|
|
133
|
+
function caseName(prefix, label, i) {
|
|
134
|
+
const safe = label.replace(/[^A-Za-z0-9_.-]/g, '_');
|
|
135
|
+
return `${prefix}${i}-${safe}`.slice(0, 64);
|
|
136
|
+
}
|
|
137
|
+
/**
|
|
138
|
+
* Self-routing invariants: fed its own centroid, each label must score
|
|
139
|
+
* 1 ± tolerance and every other label at most `1 - minGap`. A failure means
|
|
140
|
+
* two labels are (near-)duplicates or the artifact is corrupt — the router
|
|
141
|
+
* could not separate them even on their own means.
|
|
142
|
+
*
|
|
143
|
+
* Returned as several suites when there are more labels than one suite allows.
|
|
144
|
+
*/
|
|
145
|
+
export function centroidSelfRoutingSuites(artifact, opts = {}) {
|
|
146
|
+
const tol = opts.tolerance ?? SELF_SCORE_TOLERANCE;
|
|
147
|
+
const minGap = opts.minGap ?? 0.05;
|
|
148
|
+
if (!(tol >= 0 && tol < 0.5))
|
|
149
|
+
throw new RangeError('tolerance must be in [0, 0.5)');
|
|
150
|
+
if (!(minGap > 0 && minGap < 1))
|
|
151
|
+
throw new RangeError('minGap must be in (0, 1)');
|
|
152
|
+
const n = artifact.labels.length;
|
|
153
|
+
const cases = artifact.centroids.map((c, i) => ({
|
|
154
|
+
name: caseName('self-', artifact.labels[i], i),
|
|
155
|
+
inputs: c.slice(),
|
|
156
|
+
rows: 1,
|
|
157
|
+
// Unit vectors: every score is within [-1, 1]; pad by tol for rounding.
|
|
158
|
+
minimum: Array.from({ length: n }, (_, j) => (j === i ? 1 - tol : -1 - tol)),
|
|
159
|
+
maximum: Array.from({ length: n }, (_, j) => (j === i ? 1 + tol : 1 - minGap)),
|
|
160
|
+
}));
|
|
161
|
+
const suites = [];
|
|
162
|
+
for (let i = 0; i < cases.length; i += MAX_CASES_PER_SUITE) {
|
|
163
|
+
suites.push({ schema: 'ruv-fann.invariants/1', cases: cases.slice(i, i + MAX_CASES_PER_SUITE) });
|
|
164
|
+
}
|
|
165
|
+
return suites;
|
|
166
|
+
}
|
|
167
|
+
/**
|
|
168
|
+
* Read a JSON file the user named. Refuses non-regular files (FIFOs, devices,
|
|
169
|
+
* directories), symlinks that leave nothing to read, and anything larger
|
|
170
|
+
* than MAX_INPUT_BYTES, before reading it into memory.
|
|
171
|
+
*/
|
|
172
|
+
export function readJsonInput(path, what, maxBytes = MAX_INPUT_BYTES) {
|
|
173
|
+
if (typeof path !== 'string' || path.length === 0 || path.includes('\0')) {
|
|
174
|
+
throw new Error(`${what}: a file path is required`);
|
|
175
|
+
}
|
|
176
|
+
const real = realpathSync(resolvePath(path));
|
|
177
|
+
const st = lstatSync(real);
|
|
178
|
+
if (!st.isFile())
|
|
179
|
+
throw new Error(`${what}: ${path} is not a regular file`);
|
|
180
|
+
if (st.size > maxBytes)
|
|
181
|
+
throw new Error(`${what}: ${path} is ${st.size} bytes; limit is ${maxBytes}`);
|
|
182
|
+
const text = readFileSync(real, 'utf8');
|
|
183
|
+
try {
|
|
184
|
+
return JSON.parse(text);
|
|
185
|
+
}
|
|
186
|
+
catch (err) {
|
|
187
|
+
throw new Error(`${what}: ${path} is not valid JSON (${err instanceof Error ? err.message : String(err)})`);
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
/** Shape check before handing a user model to WSP (which validates fully). */
|
|
191
|
+
export function assertDenseModel(x, what = 'model') {
|
|
192
|
+
const m = x;
|
|
193
|
+
if (!m || typeof m !== 'object' || m.schema !== 'ruv-fann.dense-layers/1' || !Array.isArray(m.layers) || m.layers.length === 0) {
|
|
194
|
+
throw new Error(`${what}: expected a ruv-fann.dense-layers/1 model with at least one layer`);
|
|
195
|
+
}
|
|
196
|
+
return m;
|
|
197
|
+
}
|
|
198
|
+
/** Run the self-routing invariants against a centroid artifact. */
|
|
199
|
+
export async function checkCentroidSelfRouting(mods, artifact, opts = {}) {
|
|
200
|
+
const t0 = performance.now();
|
|
201
|
+
const model = centroidToDenseModel(artifact);
|
|
202
|
+
const suites = centroidSelfRoutingSuites(artifact, opts);
|
|
203
|
+
let accepted = true, checks = 0, backend = '', modelHash = '';
|
|
204
|
+
const violations = [];
|
|
205
|
+
for (const suite of suites) {
|
|
206
|
+
const r = await mods.invariants.checkModelInvariants(model, suite);
|
|
207
|
+
accepted &&= r.accepted === true;
|
|
208
|
+
checks += r.checks;
|
|
209
|
+
backend = r.backend;
|
|
210
|
+
modelHash = r.modelHash;
|
|
211
|
+
for (const v of r.violations) {
|
|
212
|
+
violations.push({ case: v.case, output: artifact.labels[v.output] ?? String(v.output), constraint: v.constraint, actual: v.actual, bound: v.bound });
|
|
213
|
+
}
|
|
214
|
+
}
|
|
215
|
+
return { accepted, modelHash, labels: artifact.labels.length, suites: suites.length, checks, violations, backend, ms: Math.round(performance.now() - t0) };
|
|
216
|
+
}
|
|
217
|
+
/** Test hook. */
|
|
218
|
+
export function __resetWspForTests() {
|
|
219
|
+
_load = null;
|
|
220
|
+
}
|
|
221
|
+
//# sourceMappingURL=ruv-fann-wsp.js.map
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@claude-flow/cli",
|
|
3
|
-
"version": "3.
|
|
3
|
+
"version": "3.77.1",
|
|
4
4
|
"type": "module",
|
|
5
5
|
"description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
|
|
6
6
|
"main": "dist/src/index.js",
|
|
@@ -134,12 +134,12 @@
|
|
|
134
134
|
"ws": "^8.21.0",
|
|
135
135
|
"yaml": "^2.8.0",
|
|
136
136
|
"zod": "^3.22.0",
|
|
137
|
-
"@claude-flow/memory": "3.3.
|
|
137
|
+
"@claude-flow/memory": "3.3.3"
|
|
138
138
|
},
|
|
139
139
|
"optionalDependencies": {
|
|
140
140
|
"@agntcy/slim-bindings": "2.1.1",
|
|
141
141
|
"@claude-flow/aidefence": "3.2.1",
|
|
142
|
-
"@claude-flow/memory": "3.3.
|
|
142
|
+
"@claude-flow/memory": "3.3.3",
|
|
143
143
|
"@metaharness/flywheel": "~0.1.10",
|
|
144
144
|
"@metaharness/radio": "~0.1.0",
|
|
145
145
|
"@metaharness/turn-credit": "~0.1.0",
|
|
@@ -149,7 +149,10 @@
|
|
|
149
149
|
"ruvector": "^0.3.13",
|
|
150
150
|
"nostr-tools": "^2.7.0",
|
|
151
151
|
"@ruvector/learning-wasm": "0.1.29",
|
|
152
|
-
"agent-booster": "^0.2.2"
|
|
152
|
+
"agent-booster": "^0.2.2",
|
|
153
|
+
"ruv-fann-wsp": "0.2.0",
|
|
154
|
+
"ruv-fann-wsp-invariants": "0.1.0",
|
|
155
|
+
"ruv-fann-wsp-lifecycle": "0.1.0"
|
|
153
156
|
},
|
|
154
157
|
"peerDependencies": {
|
|
155
158
|
"@metaharness/router": "^0.4.0",
|