@ruvector/ruvllm 4.0.1 → 4.1.0

package/LICENSE

@@ -1,201 +0,0 @@
-Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Alibaba Cloud
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/NOTICE

@@ -1,9 +0,0 @@
-RuFlo Code Model
-Copyright 2026 rUv and contributors
-
-Original experiment code and synthetic tool traces are licensed under Apache 2.0.
-Base model: Qwen/Qwen3.5-4B, Apache 2.0, owned by the Qwen team.
-HumanEval data in data/external is MIT licensed; see HumanEval.LICENSE.
-MLX LM, Transformers, PEFT, and Claude Code Router retain their respective licenses.
-Claude Code is a separate proprietary client. No Claude model weights or private
-Claude training data are included. This project is not endorsed by Anthropic.

package/examples/gpu-loop.example.json

@@ -1,26 +0,0 @@
-{
-  "schema": "ruvllm-gpu-loop/v1",
-  "stateRoot": "/absolute/private/gpu-loop-state",
-  "intervalSeconds": 60,
-  "maxAttempts": 2,
-  "budgetUsd": 0,
-  "jobs": [
-    {
-      "id": "qwen35-4b-paired-evaluation",
-      "provider": "vast.ai",
-      "model": {
-        "repo": "Qwen/Qwen3.5-4B",
-        "revision": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a"
-      },
-      "task": "evaluate",
-      "secretRef": "ruos.vast.primary",
-      "resource": { "instanceId": "REPLACE_WITH_EXISTING_INSTANCE_ID" },
-      "maxCostUsd": 1,
-      "timeoutSeconds": 1800,
-      "experiment": {
-        "configPath": "/absolute/private/operator-profile/runtime.json",
-        "planPath": "/absolute/experiment-inputs/plan.json"
-      }
-    }
-  ]
-}

package/src/adapters-cli.mjs

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { exportArchive, trainingPlan, selectDevelopmentCandidate } from './adapters.mjs';
-
-const operations = { export: exportArchive, 'training-plan': trainingPlan, select: selectDevelopmentCandidate };
-if (process.argv.length !== 3 || !Object.hasOwn(operations, process.argv[2])) {
-  process.stderr.write('Usage: node src/adapters-cli.mjs export|training-plan|select < input.json\nJSON data only; no training, inference or activation is executed.\n');
-  process.exitCode = process.argv[2] === '--help' ? 0 : 2;
-} else {
-  try {
-    const chunks = [];
-    let bytes = 0;
-    for await (const chunk of process.stdin) {
-      bytes += chunk.length;
-      if (bytes > 16 * 1024 * 1024) throw new Error('Input exceeds 16 MiB');
-      chunks.push(chunk);
-    }
-    const input = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-    process.stdout.write(JSON.stringify(await operations[process.argv[2]](input), null, 2) + '\n');
-  } catch (error) {
-    process.stderr.write(JSON.stringify({ ok: false, error: error.message }) + '\n');
-    process.exitCode = 1;
-  }
-}

package/src/adapters.mjs

@@ -1,91 +0,0 @@
-// MetaHarness adapters are data-only: no provider requests, trainer launch or activation.
-import { createHash } from 'node:crypto';
-import { exportTrainingData, twoStagePlan } from '@metaharness/weight-eft';
-import { runContrastive, digestDocument } from '@metaharness/darwin/contrastive';
-
-const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex');
-const require = (condition, message) => { if (!condition) throw new Error(message); };
-const identifier = value => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/.test(value);
-
-/** Export reviewed caller-asserted trajectories; held-out instance IDs are always excluded. */
-export function exportArchive({ archive, evalHoldout, maxTokens = 12000 }) {
-  require(Array.isArray(archive) && archive.length <= 10000, 'Archive limit is 10000 trajectories');
-  require(Array.isArray(evalHoldout) && evalHoldout.every(identifier), 'Explicit eval holdout IDs required');
-  require(Number.isInteger(maxTokens) && maxTokens >= 1 && maxTokens <= 32768, 'Invalid token budget');
-  require(Buffer.byteLength(JSON.stringify(archive)) <= 16 * 1024 * 1024, 'Archive exceeds 16 MiB');
-  for (const row of archive) {
-    require(row && identifier(row.instance_id) && typeof row.model === 'string' && row.model.length > 0,
-      'Invalid trajectory identity');
-    require(['cheap', 'frontier'].includes(row.tier) && typeof row.resolved === 'boolean', 'Invalid trajectory outcome');
-    require(typeof row.model_patch === 'string' && Array.isArray(row.messages) && row.messages.length <= 4096,
-      'Invalid trajectory content');
-    for (const message of row.messages) {
-      require(message && ['system', 'user', 'assistant', 'tool'].includes(message.role)
-        && (typeof message.content === 'string' || message.content === null), 'Invalid message');
-    }
-  }
-  const result = exportTrainingData(archive, {
-    evalHoldout, maxTokens, truncateOverLength: false, dropRewardHacked: true,
-  });
-  return {
-    schema: 'ruvllm-training-export/v1', ...result,
-    archiveSha256: hash(archive), holdoutSha256: hash(evalHoldout),
-    evidenceOrigin: 'caller-asserted-trajectories', trainingExecuted: false,
-    productionActivation: false,
-  };
-}
-
-/** Upstream command is informational; this checkout has no `ruvllm microlora` CLI. */
-export function trainingPlan({ base, sftPath, dpoPath, adapterPrefix }) {
-  require(base && typeof base.id === 'string' && Number.isFinite(base.paramsB), 'Invalid model');
-  for (const path of [sftPath, dpoPath, adapterPrefix]) require(typeof path === 'string' && path.length > 0, 'Path required');
-  return {
-    schema: 'ruvllm-training-plan/v1',
-    plans: twoStagePlan(base, sftPath, dpoPath, adapterPrefix),
-    executionStatus: 'not_executed',
-    runnerCompatibility: 'adapter-required',
-    reason: 'The upstream ruvllm microlora command is not implemented by this standalone checkout. Use a separately validated trainer; DPO requires an additional trainer implementation.',
-    productionActivation: false,
-  };
-}
-
-/** Replay bounded measured scores through Darwin. This ranks development evidence only. */
-export async function selectDevelopmentCandidate({ baseline, candidates, envelope }) {
-  require(envelope && typeof envelope === 'object' && !Array.isArray(envelope), 'Immutable experiment envelope required');
-  require(Array.isArray(candidates) && candidates.length > 0 && candidates.length <= 32, 'Expected 1..32 candidates');
-  const all = [baseline, ...candidates];
-  for (const candidate of all) {
-    require(candidate && identifier(candidate.id) && Number.isFinite(candidate.score)
-      && candidate.score >= 0 && candidate.score <= 1
-      && /^[a-f0-9]{64}$/.test(candidate.evidenceSha256), 'Invalid measured candidate');
-  }
-  require(new Set(all.map(row => row.id)).size === all.length, 'Duplicate candidate ID');
-  const byId = new Map(all.map(row => [row.id, { ...row }]));
-  const best = candidates.reduce((a, b) => b.score > a.score ? b : a);
-  const document = { components: [{ id: 'weight-candidate', scope: 'domain', content: { id: baseline.id } }] };
-  const result = await runContrastive({
-    tenantId: 'local', projectId: 'ruvllm', task: { purpose: 'development-candidate-selection' },
-    environment: { mode: 'evidence-replay' },
-    library: { tenantId: 'local', projectId: 'ruvllm', entries: [] },
-    envelope, baseline: document,
-    budget: { maxUsd: 0, maxCalls: 5, timeoutMs: 5000, probeUsd: 0, proposeUsd: 0, composeUsd: 0 },
-    evaluator: {
-      surfaceAware: true,
-      async probe({ candidate }) {
-        const row = byId.get(candidate.components[0].content.id);
-        require(row, 'Unmeasured candidate');
-        return { appliedDigest: digestDocument(candidate), score: row.score, costUsd: 0,
-          observations: [{ id: 'measured-failure', componentId: 'weight-candidate', message: `Bound evidence ${row.evidenceSha256}` }] };
-      },
-    },
-    proposer: {
-      async propose({ scope }) {
-        return { edits: scope === 'domain' ? [{ componentId: 'weight-candidate', content: { id: best.id },
-          citations: ['measured-failure'] }] : [], costUsd: 0 };
-      },
-    },
-  });
-  return { schema: 'ruvllm-development-selection/v1', selectedId: result.candidate.components[0].content.id,
-    envelopeSha256: hash(envelope), evidenceSha256: hash(all), evidenceMode: 'score-replay',
-    result, independentConfirmation: false, productionActivation: false };
-}

package/src/cli.mjs

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { runExperiment } from './engine.mjs';
-import { createFixture } from './fixture.mjs';
-
-const [command, ...args] = process.argv.slice(2);
-function options(allowed) {
-  const result = {};
-  for (let i = 0; i < args.length; i += 2) {
-    if (!allowed.includes(args[i]) || !args[i + 1] || Object.hasOwn(result, args[i])) throw new Error('Unknown, duplicate or missing argument');
-    result[args[i]] = args[i + 1];
-  }
-  return result;
-}
-try {
-  let result;
-  if (command === 'run') {
-    const flags = options(['--config', '--plan']);
-    result = await runExperiment({ configPath: flags['--config'], planPath: flags['--plan'] });
-  } else if (command === 'fixture') {
-    const flags = options(['--dir', '--binary']);
-    if (!flags['--dir'] || !flags['--binary']) throw new Error('fixture requires --dir and --binary');
-    result = await runExperiment(await createFixture({ directory: flags['--dir'], binaryPath: flags['--binary'] }));
-  } else if (command === '--help' || command === 'help') {
-    console.log('Usage: ruvllm-experiment run --config ABS --plan ABS\n       ruvllm-experiment fixture --dir NEW_ABS --binary ABS');
-    process.exit(0);
-  } else throw new Error('Expected run, fixture or --help');
-  console.log(JSON.stringify(result, null, 2));
-} catch (error) {
-  console.error(JSON.stringify({ ok: false, error: error.message, productionActivation: false })); process.exitCode = 1;
-}

package/src/engine.mjs

@@ -1,238 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { spawn } from 'node:child_process';
-import { constants } from 'node:fs';
-import { open, lstat, realpath, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { resolve, dirname, join, relative, isAbsolute, parse } from 'node:path';
-import { meetsPromotionRule, gateFingerprint } from '@metaharness/flywheel';
-import { selectDevelopmentCandidate } from './adapters.mjs';
-
-const MAX_JSON = 1024 * 1024;
-const HASH = /^[a-f0-9]{64}$/;
-const inside = (root, path) => path === root || (!relative(root, path).startsWith('..') && !isAbsolute(relative(root, path)));
-const assert = (condition, message) => { if (!condition) throw new Error(message); };
-export const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
-
-function keys(value, required, optional = []) {
-  assert(value && typeof value === 'object' && !Array.isArray(value), 'Expected JSON object');
-  assert(required.every(k => Object.hasOwn(value, k)), `Missing fields: ${required.join(', ')}`);
-  assert(Object.keys(value).every(k => [...required, ...optional].includes(k)), 'Unknown object fields');
-}
-
-// Reject duplicate object keys and non-finite numbers before applying schemas.
-export function parseJson(bytes) {
-  const text = bytes.toString('utf8'); let index = 0;
-  const ws = () => { while (/[ \t\r\n]/.test(text[index] ?? '') && index < text.length) index++; };
-  function string() {
-    const start = index++; let escaped = false;
-    while (index < text.length) {
-      const c = text[index++];
-      if (c === '"' && !escaped) return JSON.parse(text.slice(start, index));
-      if (c === '\\' && !escaped) escaped = true; else escaped = false;
-    }
-    throw new Error('Unterminated JSON string');
-  }
-  function value(depth = 0) {
-    assert(depth < 64, 'JSON nesting limit'); ws();
-    if (text[index] === '"') return string();
-    if (text[index] === '{') {
-      index++; ws(); const result = Object.create(null); const seen = new Set();
-      if (text[index] === '}') { index++; return result; }
-      while (true) {
-        ws(); assert(text[index] === '"', 'Invalid JSON key'); const key = string();
-        assert(!seen.has(key), 'Duplicate JSON key'); seen.add(key); ws();
-        assert(text[index++] === ':', 'Invalid JSON separator'); result[key] = value(depth + 1); ws();
-        const end = text[index++]; if (end === '}') return result; assert(end === ',', 'Invalid JSON object');
-      }
-    }
-    if (text[index] === '[') {
-      index++; ws(); const result = []; if (text[index] === ']') { index++; return result; }
-      while (true) { result.push(value(depth + 1)); ws(); const end = text[index++]; if (end === ']') return result; assert(end === ',', 'Invalid JSON array'); }
-    }
-    const token = /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(text.slice(index));
-    assert(token, 'Invalid JSON value'); index += token[0].length; const result = JSON.parse(token[0]);
-    assert(typeof result !== 'number' || Number.isFinite(result), 'Non-finite JSON number'); return result;
-  }
-  const result = value(); ws(); assert(index === text.length, 'Trailing JSON data'); return result;
-}
-
-export async function checkedPath(path, { directory = false, roots } = {}) {
-  assert(typeof path === 'string' && isAbsolute(path) && !path.includes('\0'), 'Expected absolute path');
-  assert(path === resolve(path), 'Path must be canonical without traversal');
-  let cursor = parse(path).root;
-  for (const part of path.slice(cursor.length).split('/').filter(Boolean)) {
-    cursor = join(cursor, part); const stat = await lstat(cursor); assert(!stat.isSymbolicLink(), 'Symlinks are forbidden');
-  }
-  const canonical = await realpath(path); const stat = await lstat(canonical);
-  assert(directory ? stat.isDirectory() : stat.isFile(), directory ? 'Expected directory' : 'Expected regular file');
-  if (roots) assert(roots.some(root => inside(root, canonical)), 'Path outside configured read roots');
-  return canonical;
-}
-
-async function boundedRead(path, limit = MAX_JSON) {
-  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-  try {
-    const stat = await file.stat(); assert(stat.isFile() && stat.size <= limit, 'Control file too large or not regular');
-    const bytes = Buffer.alloc(stat.size); const { bytesRead } = await file.read(bytes, 0, bytes.length, 0);
-    assert(bytesRead === bytes.length, 'Control file changed during read'); return bytes;
-  } finally { await file.close(); }
-}
-
-export async function fileDigest(path) {
-  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-  try {
-    assert((await file.stat()).isFile(), 'Expected regular file');
-    const hash = createHash('sha256'); const bytes = Buffer.alloc(1024 * 1024); let position = 0;
-    while (true) { const { bytesRead } = await file.read(bytes, 0, bytes.length, position); if (!bytesRead) break; hash.update(bytes.subarray(0, bytesRead)); position += bytesRead; }
-    return hash.digest('hex');
-  } finally { await file.close(); }
-}
-
-async function identicalFiles(a, b) {
-  const first = await open(a, constants.O_RDONLY | constants.O_NOFOLLOW), second = await open(b, constants.O_RDONLY | constants.O_NOFOLLOW);
-  try {
-    const size = (await first.stat()).size; if (size !== (await second.stat()).size) return false;
-    const x = Buffer.alloc(Math.min(size, 1024 * 1024)), y = Buffer.alloc(x.length);
-    for (let position = 0; position < size; position += x.length) {
-      const length = Math.min(x.length, size - position);
-      const [rx, ry] = await Promise.all([first.read(x, 0, length, position), second.read(y, 0, length, position)]);
-      if (rx.bytesRead !== length || ry.bytesRead !== length || !x.subarray(0, length).equals(y.subarray(0, length))) return false;
-    }
-    return true;
-  } finally { await first.close(); await second.close(); }
-}
-
-async function save(path, value) { await writeFile(path, JSON.stringify(value, null, 2) + '\n', { flag: 'wx', mode: 0o600 }); }
-
-async function runtime(configPath) {
-  configPath = await checkedPath(configPath); const bytes = await boundedRead(configPath); const config = parseJson(bytes);
-  keys(config, ['schema', 'binaryPath', 'binarySha256', 'readRoots', 'writeRoot', 'policySha256s', 'maxCandidates', 'timeoutMs']);
-  assert(config.schema === 'ruvllm-experiment-runtime/v1', 'Unsupported runtime schema');
-  assert(HASH.test(config.binarySha256), 'Invalid binary digest');
-  assert(Array.isArray(config.readRoots) && config.readRoots.length > 0 && config.readRoots.length <= 32, 'Invalid read roots');
-  assert(Array.isArray(config.policySha256s) && config.policySha256s.length > 0 && config.policySha256s.length <= 128 && config.policySha256s.every(x => HASH.test(x)), 'Invalid approved policy digests');
-  assert(Number.isInteger(config.maxCandidates) && config.maxCandidates >= 1 && config.maxCandidates <= 16, 'Candidate limit must be 1..16');
-  assert(Number.isInteger(config.timeoutMs) && config.timeoutMs >= 100 && config.timeoutMs <= 300000, 'Invalid timeout');
-  config.readRoots = await Promise.all(config.readRoots.map(path => checkedPath(path, { directory: true })));
-  config.writeRoot = await checkedPath(config.writeRoot, { directory: true });
-  config.binaryPath = await checkedPath(config.binaryPath);
-  assert(!inside(config.writeRoot, configPath) && !inside(config.writeRoot, config.binaryPath), 'Runtime config and binary must be outside write root');
-  const stat = await lstat(configPath); assert((stat.mode & 0o077) === 0, 'Runtime config must be owner-only');
-  assert(((await lstat(config.writeRoot)).mode & 0o077) === 0, 'Write root must be private');
-  assert(await fileDigest(config.binaryPath) === config.binarySha256, 'Binary digest mismatch');
-  return { ...config, configSha256: sha256(bytes) };
-}
-
-async function native(config, request) {
-  assert(await fileDigest(config.binaryPath) === config.binarySha256, 'Binary digest mismatch');
-  const input = JSON.stringify(request); assert(Buffer.byteLength(input) <= 64 * 1024, 'Native request limit');
-  return new Promise((accept, reject) => {
-    const environment = Object.fromEntries(['PATH', 'HOME', 'TMPDIR', 'LANG', 'LC_ALL'].filter(k => process.env[k]).map(k => [k, process.env[k]]));
-    const child = spawn(config.binaryPath, [], { stdio: ['pipe', 'pipe', 'pipe'], env: environment, shell: false });
-    let stdout = [], stderr = [], outSize = 0, errSize = 0, failure;
-    const fail = message => { failure ??= new Error(message); child.kill('SIGKILL'); };
-    const timer = setTimeout(() => fail('Native operation timed out'), config.timeoutMs);
-    child.stdout.on('data', bytes => { outSize += bytes.length; if (outSize > MAX_JSON) fail('Native stdout limit'); else stdout.push(bytes); });
-    child.stderr.on('data', bytes => { errSize += bytes.length; if (errSize > 64 * 1024) fail('Native stderr limit'); else stderr.push(bytes); });
-    child.on('error', error => { clearTimeout(timer); reject(error); });
-    child.stdin.on('error', () => {});
-    child.on('close', code => {
-      clearTimeout(timer); if (failure) return reject(failure);
-      if (code !== 0) return reject(new Error(`Native ${request.op} rejected: ${Buffer.concat(stderr).toString('utf8').slice(0, 2048)}`));
-      try { accept(parseJson(Buffer.concat(stdout))); } catch (error) { reject(error); }
-    });
-    child.stdin.end(input);
-  });
-}
-
-export async function runExperiment({ configPath, planPath }) {
-  const config = await runtime(configPath); planPath = await checkedPath(planPath, { roots: config.readRoots });
-  const planBytes = await boundedRead(planPath), plan = parseJson(planBytes);
-  keys(plan, ['schema', 'evidenceMode', 'source', 'policy', 'candidates']);
-  assert(plan.schema === 'ruvllm-experiment-plan/v1', 'Unsupported plan schema');
-  assert(['fixture', 'external'].includes(plan.evidenceMode), 'Explicit fixture or external evidence mode required');
-  assert(Array.isArray(plan.candidates) && plan.candidates.length >= 1 && plan.candidates.length <= config.maxCandidates, 'Candidate limit exceeded');
-  const source = await checkedPath(plan.source, { roots: config.readRoots });
-  const policyPath = await checkedPath(plan.policy, { roots: config.readRoots });
-  const policyBytes = await boundedRead(policyPath), policy = parseJson(policyBytes), policySha256 = sha256(policyBytes);
-  assert(config.policySha256s.includes(policySha256), 'Policy is not approved');
-  assert(Array.isArray(policy.allowed_tensors) && policy.allowed_tensors.length > 0 && policy.allowed_tensors.length <= 256, 'Invalid tensor selection');
-  const ids = new Set(), candidates = [];
-  for (const candidate of plan.candidates) {
-    keys(candidate, ['id', 'patch'], ['evaluation']);
-    assert(typeof candidate.id === 'string' && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(candidate.id) && !ids.has(candidate.id), 'Invalid or duplicate candidate id'); ids.add(candidate.id);
-    const patchPath = await checkedPath(candidate.patch, { roots: config.readRoots }), patchBytes = await boundedRead(patchPath);
-    const entry = { ...candidate, patchBytes, patch: parseJson(patchBytes) };
-    if (candidate.evaluation) { const path = await checkedPath(candidate.evaluation, { roots: config.readRoots }); entry.evaluationBytes = await boundedRead(path); entry.evaluationValue = parseJson(entry.evaluationBytes); }
-    candidates.push(entry);
-  }
-  const runDirectory = join(config.writeRoot, `run-${randomUUID()}`); await mkdir(runDirectory, { mode: 0o700 });
-  await writeFile(join(runDirectory, 'plan.json'), planBytes, { flag: 'wx', mode: 0o600 });
-  const copiedPolicy = join(runDirectory, 'policy.json'); await writeFile(copiedPolicy, policyBytes, { flag: 'wx', mode: 0o600 });
-  const inspection = await native(config, { op: 'inspect', source, tensors: policy.allowed_tensors });
-  const reportPath = join(runDirectory, 'report.json');
-  const report = { schema: 'ruvllm-experiment-report/v1', evidenceMode: plan.evidenceMode, sourceSha256: inspection.source_sha256,
-    policySha256, planSha256: sha256(planBytes), binarySha256: config.binarySha256, configSha256: config.configSha256,
-    gateSha256: gateFingerprint(meetsPromotionRule), runDirectory, reportPath, productionActivation: false, activationAuthorized: false,
-    inferencePerformed: false, independentConfirmation: false, evaluationTrust: 'caller-supplied; not independent attestation', costMetered: false, candidates: [], selectedCandidateId: null };
-  let sharedEvaluation, baselineScore;
-  for (const candidate of candidates) {
-    const output = join(runDirectory, candidate.id); await mkdir(output, { mode: 0o700 });
-    const patch = join(output, 'patch.json'), checkpoint = join(output, 'candidate.safetensors'), receiptPath = join(output, 'receipt.json');
-    await writeFile(patch, candidate.patchBytes, { flag: 'wx', mode: 0o600 });
-    const result = { id: candidate.id, status: 'rejected', patchSha256: sha256(candidate.patchBytes), rollbackExact: false, rollbackVerified: false, rvfVerified: false, productionActivation: false };
-    let receipt;
-    try {
-      assert(candidate.patch.source_sha256 === report.sourceSha256, 'Patch source mismatch');
-      receipt = await native(config, { op: 'patch', source, output: checkpoint, patch, policy: copiedPolicy });
-      assert(receipt.source_sha256 === report.sourceSha256 && receipt.policy_sha256 === policySha256 && receipt.patch_sha256 === result.patchSha256 && receipt.activation_authorized === false, 'Native receipt binding mismatch');
-      await save(receiptPath, receipt); result.candidateSha256 = receipt.candidate_sha256; result.status = 'unqualified';
-      let evaluationPath;
-      if (candidate.evaluationBytes) {
-        evaluationPath = join(output, 'evaluation.json'); await writeFile(evaluationPath, candidate.evaluationBytes, { flag: 'wx', mode: 0o600 });
-        const value = candidate.evaluationValue;
-        result.evaluationSha256 = sha256(candidate.evaluationBytes);
-        // All candidates must use the same suite, baseline, runtime and protocol.
-        const signature = JSON.stringify([value.suite_sha256, value.protocol_sha256, value.baseline, value.total, value.baseline_correct, value.baseline_truncated, value.baseline_output_sha256]);
-        const validation = await native(config, { op: 'evaluate', evaluation: evaluationPath, receipt: receiptPath });
-        assert(validation.valid === true && validation.activation_authorized === false, 'Evaluation not valid');
-        if (sharedEvaluation) assert(sharedEvaluation === signature, 'Candidates evaluated against different baselines or suites'); else sharedEvaluation = signature;
-        const total = value.total;
-        assert(Number.isInteger(total) && total > 0, 'Evaluation total must be positive');
-        const score = (correct, truncated) => ({ primary: correct / total, noopRate: truncated / total, costPerWin: 0, regressed: false });
-        baselineScore = value.baseline_correct / total;
-        const gate = meetsPromotionRule({ baseline: score(value.baseline_correct, value.baseline_truncated), candidate: score(value.candidate_correct, value.candidate_truncated) });
-        if (value.candidate_correct <= value.baseline_correct) { gate.promote = false; gate.reasons.push('no_strict_accuracy_improvement'); }
-        result.gate = { ...gate, meaning: 'research qualification only; no activation authority' };
-        result.score = score(value.candidate_correct, value.candidate_truncated);
-        result.status = gate.promote ? 'qualified' : 'unqualified';
-      } else result.gate = { promote: false, reasons: ['missing_evaluation'] };
-      const artifact = join(output, 'evidence.rvf');
-      const exported = await native(config, { op: 'export', patch, policy: copiedPolicy, receipt: receiptPath, output: artifact, ...(evaluationPath ? { evaluation: evaluationPath } : {}) });
-      const verified = await native(config, { op: 'verify', artifact, expected_sha256: exported.sha256 });
-      assert(verified.integrity_verified === true && verified.activation_authorized === false, 'RVF verification failed'); result.rvfSha256 = exported.sha256; result.rvfVerified = true;
-    } catch (error) { result.status = 'rejected'; result.error = error.message; }
-    finally {
-      if (receipt) {
-        const restored = join(output, 'restored.safetensors');
-        const rollback = await native(config, { op: 'rollback', source: checkpoint, output: restored, patch, policy: copiedPolicy, receipt: receiptPath });
-        result.restoredSha256 = rollback.candidate_sha256;
-        result.rollbackExact = result.rollbackVerified = rollback.candidate_sha256 === report.sourceSha256 && await identicalFiles(source, restored);
-        assert(result.rollbackExact, 'Rollback did not restore original bytes');
-      }
-    }
-    report.candidates.push(result);
-  }
-  assert(await fileDigest(source) === report.sourceSha256, 'Source checkpoint changed during experiment');
-  const qualified = report.candidates.filter(candidate => candidate.status === 'qualified');
-  qualified.sort((a, b) => b.score.primary - a.score.primary || a.score.noopRate - b.score.noopRate || a.id.localeCompare(b.id));
-  if (qualified.length) {
-    report.developmentSelection = await selectDevelopmentCandidate({
-      baseline: { id: 'source.baseline', score: baselineScore, evidenceSha256: report.sourceSha256 },
-      candidates: qualified.map(candidate => ({ id: candidate.id, score: candidate.score.primary, evidenceSha256: candidate.evaluationSha256 })),
-      envelope: Object.fromEntries(['sourceSha256', 'policySha256', 'binarySha256', 'gateSha256', 'planSha256'].map(key => [key, report[key]])),
-    });
-    assert(qualified.some(candidate => candidate.id === report.developmentSelection.selectedId), 'Darwin selected an unqualified candidate');
-    report.selectedCandidateId = report.developmentSelection.selectedId;
-  }
-  await save(reportPath, report); return report;
-}