claude-flow 3.19.0 → 3.21.0

package/v3/@claude-flow/cli/dist/src/services/weight-eft.js

@@ -0,0 +1,296 @@
+/**
+ * weight-eft.ts — Optional-dependency service wrapper around
+ * `@metaharness/weight-eft` (agenticow / ADR-150 weight-eft slice).
+ *
+ * WHAT THIS SHIPS (and what it deliberately does NOT)
+ * ---------------------------------------------------
+ * This service turns ruflo's captured run transcripts into AUDITED TRAINING
+ * DATA + a COST-PARETO measurement + a GPU TRAINING PLAN. It does NOT train a
+ * model and it does NOT "reduce escalation":
+ *   - `runExport`  → SFT (OpenAI chat) + DPO (TRL preference) JSONL + a guard
+ *                    report (contamination / reward-hack / long-context). $0.
+ *   - `runPlan`    → the GPU training plan + the exact `ruvllm microlora`
+ *                    command a GPU host would run. $0 dry-run — never spawns.
+ *   - `runEval`    → the cost-Pareto delta folded from two CascadeOutcome[]. $0.
+ *   - `runRemoteTrain` → an SSH-based remote-GPU invocation. DRY-RUN by default
+ *                    (prints commands + read-only preflight); real compute only
+ *                    behind explicit `execute && yes`. This is the ONLY path
+ *                    that can spend, and it spends on the USER's host, not $0.
+ *
+ * HARD HONESTY RULE (do not overclaim): weight-eft's own `train` never spawns
+ * (its README §Status), and no GPU tune has run here. `resolved` in the
+ * captured archive is a PROXY (ruflo has no SWE-bench gold oracle) — the SFT
+ * data-quality caveat stands. Nothing here claims ruflo "trains a model" as a
+ * $0/local capability.
+ *
+ * ADR-150 GRACEFUL DEGRADATION
+ * ----------------------------
+ * `@metaharness/weight-eft` is an OPTIONAL dependency. Every entry point loads
+ * it via a dynamic import through `loadWeightEft()` and returns a structured
+ * `{ degraded: true }` result when it is absent — never a throw. There is NO
+ * static `import … from '@metaharness/weight-eft'` anywhere in this file; the
+ * types below are LOCAL mirrors so tsc stays green with the package removed.
+ *
+ * @module services/weight-eft
+ */
+import { spawnSync } from 'node:child_process';
+const WEIGHT_EFT_PKG = '@metaharness/weight-eft';
+/**
+ * Load `@metaharness/weight-eft` (optional dep). Returns the module or `null`
+ * when it is absent/broken. Never throws. The specifier is held in a variable
+ * so tsc does not statically resolve the package (keeps the build green when
+ * the optional dep is removed — ADR-150).
+ */
+export async function loadWeightEft(importer) {
+    const load = importer ?? (() => import(/* @vite-ignore */ WEIGHT_EFT_PKG));
+    try {
+        const mod = (await load());
+        const api = (mod && typeof mod.exportTrainingData === 'function' ? mod : mod?.default);
+        if (!api || typeof api.exportTrainingData !== 'function')
+            return null;
+        return api;
+    }
+    catch {
+        return null; // MODULE_NOT_FOUND or any load error → degraded
+    }
+}
+/**
+ * Map captured ruflo run transcripts to the DarwinTrajectory[] contract the
+ * weight-eft exporter codes against. PURE + synchronous — this is the seam the
+ * archive-builder unit test exercises.
+ *
+ * A record is skipped (not thrown) when it lacks the minimum an exporter needs:
+ * an instance_id and a non-empty messages array. `resolved` is copied verbatim
+ * and its proxy provenance is tallied so the caller can print an honest note.
+ */
+export function buildArchiveFromRecords(records) {
+    const trajectories = [];
+    const stats = {
+        total: 0, resolved: 0, byTier: { cheap: 0, frontier: 0 }, byResolvedSource: {}, skipped: 0,
+    };
+    let hasGold = false;
+    for (const r of records) {
+        if (!r || !r.instance_id || !Array.isArray(r.messages) || r.messages.length === 0) {
+            stats.skipped++;
+            continue;
+        }
+        const tier = r.tier === 'cheap' ? 'cheap' : 'frontier';
+        trajectories.push({
+            instance_id: r.instance_id,
+            model: r.model,
+            tier,
+            resolved: !!r.resolved,
+            messages: r.messages,
+            model_patch: r.model_patch ?? '',
+            sample: r.sample ?? 0,
+            ...(r.source ? { source: r.source } : {}),
+        });
+        stats.total++;
+        stats.byTier[tier]++;
+        if (r.resolved)
+            stats.resolved++;
+        const src = r.resolved_source ?? 'external';
+        stats.byResolvedSource[src] = (stats.byResolvedSource[src] ?? 0) + 1;
+        if (src === 'gold-oracle')
+            hasGold = true;
+    }
+    const proxyNote = hasGold
+        ? 'resolved: some records carry gold-oracle status; others are proxies (see byResolvedSource).'
+        : 'resolved is a PROXY — ruflo has no SWE-bench gold oracle. `output-verifier`/`api-success` ' +
+            'labels are explicitly-marked proxies, NOT conformant gold eval. SFT/DPO quality is bounded by this.';
+    return { trajectories, stats, proxyNote };
+}
+/** Run the weight-eft exporter over a DarwinTrajectory[] archive. $0. */
+export async function runExport(opts) {
+    const api = await loadWeightEft(opts.importer);
+    if (!api)
+        return { degraded: true, reason: 'weight-eft-not-available' };
+    try {
+        const res = api.exportTrainingData(opts.archive, {
+            evalHoldout: opts.evalHoldout ?? [],
+            ...(opts.maxTokens != null ? { maxTokens: opts.maxTokens } : {}),
+            ...(opts.truncateOverLength != null ? { truncateOverLength: opts.truncateOverLength } : {}),
+            // reward-hack filter defaults ON inside weight-eft; only forward an explicit override
+            ...(opts.dropRewardHacked != null ? { dropRewardHacked: opts.dropRewardHacked } : {}),
+        });
+        return {
+            degraded: false,
+            report: res.report,
+            sftJsonl: api.sftToJsonl(res.sft),
+            dpoJsonl: api.dpoToJsonl(res.dpo),
+            sftRows: res.sft.length,
+            dpoRows: res.dpo.length,
+        };
+    }
+    catch (e) {
+        // exportTrainingData throws on contamination-guard violation — surface it.
+        return { degraded: true, reason: `export-failed: ${e.message}` };
+    }
+}
+/** Emit the two-stage (SFT → on-policy DPO) GPU training plan. $0 dry-run. */
+export async function runPlan(opts) {
+    const api = await loadWeightEft(opts.importer);
+    if (!api)
+        return { degraded: true, reason: 'weight-eft-not-available' };
+    const base = opts.base ?? DEFAULT_BASE_MODEL;
+    try {
+        const plan = api.twoStagePlan(base, opts.sftPath, opts.dpoPath, opts.adapterPrefix ?? 'ruflo-weft');
+        return { degraded: false, base, sft: plan.sft, dpo: plan.dpo };
+    }
+    catch (e) {
+        return { degraded: true, reason: `plan-failed: ${e.message}` };
+    }
+}
+/** Fold base + adapter CascadeOutcome[] into the cost-Pareto delta. $0. */
+export async function runEval(opts) {
+    const api = await loadWeightEft(opts.importer);
+    if (!api)
+        return { degraded: true, reason: 'weight-eft-not-available' };
+    try {
+        return { degraded: false, delta: api.costParetoDelta(opts.baseOutcomes, opts.adapterOutcomes) };
+    }
+    catch (e) {
+        return { degraded: true, reason: `eval-failed: ${e.message}` };
+    }
+}
+/** Default cheap-tier tune target — a 7B coder in the tunable [1,14]B band. */
+export const DEFAULT_BASE_MODEL = { id: 'Qwen/Qwen2.5-Coder-7B-Instruct', paramsB: 7 };
+function sshTarget(args) {
+    return args.sshUser ? `${args.sshUser}@${args.host}` : args.host;
+}
+function sshBase(port) {
+    return ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8', '-p', String(port)];
+}
+/** Render an argv as a copy-pasteable shell line (quoting args with spaces). */
+function renderCmd(argv) {
+    return argv.map((a) => (/[\s"'$]/.test(a) ? `'${a.replace(/'/g, `'\\''`)}'` : a)).join(' ');
+}
+/**
+ * Construct the exact ssh/rsync/ruvllm invocations a remote GPU tune would run.
+ * PURE — no spawning, no filesystem, deterministic. This is the seam the
+ * command-construction unit test exercises. The ruvllm commands mirror the
+ * canonical `ruvllm microlora sft … && ruvllm microlora dpo --init-from …`
+ * plan weight-eft emits, wrapped for SSH execution on the remote host.
+ */
+export function buildRemoteTrainInvocation(args) {
+    const base = args.base ?? DEFAULT_BASE_MODEL.id;
+    const port = args.sshPort ?? 22;
+    const runId = args.runId ?? `weft-${Date.now().toString(36)}`;
+    const prefix = args.adapterPrefix ?? 'ruflo-weft';
+    const remoteWorkdir = args.remoteWorkdir ?? `~/.ruflo-weft/${runId}`;
+    const adapterDir = args.adapterDir ?? '.claude-flow/neural';
+    const target = sshTarget(args);
+    const ssh = sshBase(port);
+    const rsyncSsh = `ssh -p ${port}`;
+    const sftAdapter = `${prefix}-${runId}-sft`;
+    const dpoAdapter = `${prefix}-${runId}-dpo`;
+    const preflight = [
+        { label: 'ssh reachability', argv: ['ssh', ...ssh, target, 'true'] },
+        { label: 'ruvllm version', argv: ['ssh', ...ssh, target, 'ruvllm --version || echo RUVLLM_MISSING'] },
+        { label: 'gpu probe', argv: ['ssh', ...ssh, target, 'nvidia-smi -L || echo NO_NVIDIA_SMI'] },
+    ];
+    const sftCmd = `cd ${remoteWorkdir} && ruvllm microlora sft --base ${base} --data sft.jsonl --output ${sftAdapter}`;
+    const dpoCmd = `cd ${remoteWorkdir} && ruvllm microlora dpo --base ${base} --init-from ${sftAdapter} ` +
+        `--data dpo.jsonl --output ${dpoAdapter}`;
+    const steps = [
+        { label: 'remote mkdir', argv: ['ssh', ...ssh, target, `mkdir -p ${remoteWorkdir}`] },
+        { label: 'rsync sft up', argv: ['rsync', '-az', '-e', rsyncSsh, args.sftPath, `${target}:${remoteWorkdir}/sft.jsonl`] },
+        { label: 'rsync dpo up', argv: ['rsync', '-az', '-e', rsyncSsh, args.dpoPath, `${target}:${remoteWorkdir}/dpo.jsonl`] },
+        { label: 'ruvllm sft (real GPU compute)', argv: ['ssh', ...ssh, target, sftCmd] },
+        { label: 'ruvllm dpo (real GPU compute)', argv: ['ssh', ...ssh, target, dpoCmd] },
+        { label: 'rsync adapter back', argv: ['rsync', '-az', '-e', rsyncSsh, `${target}:${remoteWorkdir}/${dpoAdapter}/`, `${adapterDir}/${dpoAdapter}/`] },
+    ];
+    return {
+        host: args.host, base, runId, remoteWorkdir, adapterDir, sftAdapter, dpoAdapter,
+        preflight, steps,
+        humanCommands: [...preflight, ...steps].map((s) => renderCmd(s.argv)),
+    };
+}
+/**
+ * Run (or, by default, DRY-RUN) a remote-GPU tune. SAFETY MODEL:
+ *   - DEFAULT (no execute): builds the plan, runs read-only preflight probes,
+ *     and returns the commands that WOULD run. NO rsync of data, NO training.
+ *   - execute && !yes → 'refused' (real GPU spend needs an explicit second gate).
+ *   - execute && yes  → runs preflight; if unreachable → 'preflight-failed'
+ *     WITHOUT training; else runs rsync + ssh ruvllm sft/dpo + fetch-back.
+ *   - No `ssh` binary / host unreachable / any spawn error → structured
+ *     degraded/preflight-failed. NEVER throws.
+ *
+ * `spawn` is injected for testing so CI never touches a live host.
+ */
+export async function runRemoteTrain(args) {
+    let plan;
+    try {
+        plan = buildRemoteTrainInvocation(args);
+    }
+    catch (e) {
+        return { degraded: true, reason: `plan-construction-failed: ${e.message}` };
+    }
+    const spawn = args.spawn ?? defaultSpawn;
+    // Preflight — read-only reachability/capability probes. These DO contact the
+    // remote host (ssh ... true), so a bare dry-run must NOT run them: "no
+    // implicit remote execution" (adversarial RC finding). Probes run only when
+    // executing, or when the caller explicitly opts in with --preflight.
+    const runProbe = (s) => {
+        try {
+            const r = spawn(s.argv[0], s.argv.slice(1));
+            if (r.error)
+                return { label: s.label, ok: false, detail: r.error.message };
+            const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.trim();
+            const ok = (r.status ?? 1) === 0 && !/RUVLLM_MISSING|NO_NVIDIA_SMI/.test(out);
+            return { label: s.label, ok, detail: out.slice(0, 200) || `exit ${r.status ?? 'null'}` };
+        }
+        catch (e) {
+            return { label: s.label, ok: false, detail: e.message };
+        }
+    };
+    const doProbe = args.execute === true || args.preflight === true;
+    const preflight = doProbe ? plan.preflight.map(runProbe) : [];
+    const reachable = preflight[0]?.ok === true;
+    if (!args.execute) {
+        // Bare dry-run is fully offline — plan + commands only, no host contact.
+        return {
+            degraded: false, mode: 'dry-run', plan, preflight,
+            reason: doProbe ? undefined : 'offline dry-run — no host contacted. Add --preflight to probe reachability/GPU, or --execute --yes to train.',
+        };
+    }
+    if (!args.yes) {
+        return {
+            degraded: false, mode: 'refused', plan, preflight,
+            reason: '--execute runs REAL GPU compute on your host; re-run with --yes to confirm the spend.',
+        };
+    }
+    if (!reachable) {
+        return { degraded: false, mode: 'preflight-failed', plan, preflight, reason: 'ssh host not reachable — aborting before any data transfer or training.' };
+    }
+    // Execute the mutating steps sequentially, stopping at the first failure.
+    const steps = [];
+    for (const s of plan.steps) {
+        let entry;
+        try {
+            const r = spawn(s.argv[0], s.argv.slice(1));
+            const out = `${r.stdout ?? ''}${r.stderr ?? ''}`.trim();
+            entry = { label: s.label, ok: !r.error && (r.status ?? 1) === 0, detail: r.error ? r.error.message : (out.slice(0, 200) || `exit ${r.status ?? 'null'}`) };
+        }
+        catch (e) {
+            entry = { label: s.label, ok: false, detail: e.message };
+        }
+        steps.push(entry);
+        if (!entry.ok)
+            break;
+    }
+    return { degraded: false, mode: 'executed', plan, preflight, steps };
+}
+/** Default spawn — synchronous child_process, imported lazily so this module
+ *  stays importable in any environment. Never throws (spawnSync surfaces
+ *  errors on the returned object). */
+function defaultSpawn(cmd, argv) {
+    try {
+        const r = spawnSync(cmd, argv, { encoding: 'utf8', timeout: 30 * 60 * 1000 });
+        return { status: r.status, stdout: r.stdout, stderr: r.stderr, error: r.error ?? undefined };
+    }
+    catch (e) {
+        return { status: null, error: e };
+    }
+}
+//# sourceMappingURL=weight-eft.js.map

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.19.0",
+  "version": "3.21.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",
@@ -106,8 +106,6 @@
     "yaml": "^2.8.0"
   },
   "optionalDependencies": {
-    "agentbbs": "~0.1.0",
-    "agenticow": "~0.2.3",
     "@claude-flow/aidefence": "^3.0.2",
     "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.18",
@@ -119,7 +117,7 @@
     "@metaharness/kernel": "~0.1.2",
     "@metaharness/redblue": "~0.1.4",
     "@metaharness/router": "~0.3.2",
-    "metaharness": "~0.2.8",
+    "@metaharness/weight-eft": "~0.1.1",
     "@ruvector/attention": "^0.1.32",
     "@ruvector/attention-darwin-arm64": "0.1.32",
     "@ruvector/diskann": "^0.1.0",
@@ -129,8 +127,11 @@
     "@ruvector/rvagent-wasm": "^0.1.0",
     "@ruvector/sona": "^0.1.6",
     "@ruvector/tiny-dancer": "^0.1.22",
+    "agentbbs": "~0.1.0",
     "agentdb": "^3.0.0-alpha.17",
     "agentic-flow": "^3.0.0-alpha.1",
+    "agenticow": "~0.2.4",
+    "metaharness": "~0.2.8",
     "ruvector": "^0.2.27"
   },
   "publishConfig": {