dream-cycle 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dream-cycle contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,176 @@
+# dream-cycle
+
+Dream Cycle v0: sintetiza un corpus de evaluación **post-cutoff** desde cualquier
+repo de GitHub (repo2rlenv `pr_diff`), lo calibra con agentes oracle/nop vía
+harbor, lo gatea con falsificación y corre un radar de capacidad reactivo.
+
+**El radar propone; el humano decide.**
+
+```
+  1. SINTETIZAR   repo2rlenv generate pr_diff (PRs post-cutoff, sin LLM)
+        │
+  2. ENDURECER    Dockerfiles (repos privados: set-url después del reset)
+        │
+  3. CALIBRAR     harbor oracle (gold ⇒ ~1.0) + nop (nulo ⇒ 0.0)
+        │
+  4. CURAR        tareas inevaluables (oracle < 0.999) → exclusiones DECLARADAS
+        │
+  5. GATE         oracle debe PASAR · nop debe FALLAR (falsificación)
+        │
+  6. RADAR        compara result.json entre runs → gaps con borrador de issue
+```
+
+## Alcance: dónde encaja en el loop de investigación
+
+Este paquete cubre **solo la etapa 0** del loop de auto-mejora
+([BLUEPRINT-008](https://github.com/DarkCodePE/investigador/blob/main/docs/research-flow/BLUEPRINT-008-repo2rlenv-integration.md)):
+decidir QUÉ se mejora, con corpus gateado y radar de gaps. Las etapas
+siguientes del ciclo viven fuera del paquete y **no son requisitos** para
+usarlo:
+
+| Etapa del ciclo | Pieza | Relación con este paquete |
+|---|---|---|
+| 0 — sintetizar · gatear · radar | **este paquete** | `dream-cycle run` / `radar` |
+| 2A+3A — auto-mejora del harness | [SIA](https://github.com/hexo-ai/sia) ([ADR-010](https://github.com/DarkCodePE/investigador/blob/main/docs/research-flow/ADR-010-sia-loop-integration.md)) | consume las tareas que este paquete sintetiza, vía el adapter `repo2rlenv-to-sia.py` |
+| memoria cross-run | bridge Harbor→ReasoningBank ([ADR-009](https://github.com/DarkCodePE/investigador/blob/main/docs/research-flow/ADR-009-harbor-reasoningbank-adapter.md)) | destila las trayectorias de los jobs harbor que este paquete produce |
+
+El Dream Cycle decide qué se mejora; SIA reescribe; ReasoningBank recuerda.
+SIA no detecta gaps — necesita que le den la tarea (ADR-010 §Deliberately NOT) —
+por eso el radar de este paquete es quien alimenta esa cadena.
+
+## Instalación
+
+```bash
+npm install -g dream-cycle    # o sin instalar:
+npx dream-cycle doctor
+```
+
+## Requisitos externos
+
+El paquete no trae dependencias npm, pero el subcomando `run` orquesta cuatro
+herramientas externas que debes instalar por separado. Verifícalas con
+`dream-cycle doctor`.
+
+| Herramienta | Qué es | Instalación |
+|---|---|---|
+| [repo2rlenv](https://github.com/huggingface/Repo2RLEnv) | convierte repos en entornos RL evaluables (sintetiza el corpus `pr_diff`) | `uv tool install repo2rlenv==0.8.3` (PyPI, requiere Python ≥ 3.12) |
+| [harbor](https://pypi.org/project/harbor/) | runner de agentes sobre entornos (calibración oracle/nop) | `uv tool install harbor` |
+| [gh](https://cli.github.com/) | GitHub CLI autenticado (minado de PRs) — **≥ 2.49** (`pr list --json baseRefOid`) | [releases de cli/cli](https://github.com/cli/cli/releases) + `gh auth login` |
+| [docker](https://docs.docker.com/get-docker/) | construye y corre los entornos de cada tarea | Docker Desktop o Engine, con el daemon corriendo |
+
+Si una herramienta no está en `PATH` (p. ej. la usas desde un venv local),
+apunta a ella con su variable de entorno:
+
+| Variable de entorno | Efecto |
+|---|---|
+| `REPO2RLENV_BIN` | ruta al binario `repo2rlenv` (p. ej. `.venv/bin/repo2rlenv`) |
+| `HARBOR_BIN` | ruta al binario `harbor` |
+| `GH_BIN` | ruta al binario `gh` (GitHub CLI) |
+| `DOCKER_BIN` | ruta al binario `docker` |
+| `RUNS_DIR` | sobreescribe el directorio de result.json del gate (máxima precedencia) |
+| `RADAR_JSON` | radar: emite el reporte como JSON a stdout |
+| `RADAR_NO_WRITE` | radar: no escribe `dream-cycle-radar-latest.json` |
+| `BENCH_JSON` | gate: emite el summary como JSON a stdout |
+| `BENCH_NO_WRITE` | gate: no escribe result.json |
+| `DOCKER_HOST` | socket de docker (default `unix:///var/run/docker.sock`) |
+
+Resolución de binarios: variable de entorno → `.dream-cycle/config.json`
+(`bins.<name>`) → `PATH`.
+
+### Versiones de repo2rlenv
+
+repo2rlenv saca releases con frecuencia. Este paquete NO lo congela (es una
+herramienta externa, no una dependencia npm); el manejo es por capas:
+
+1. **Versión probada declarada**: el pipeline está validado E2E contra
+   `repo2rlenv 0.8.3` — por eso la instalación recomendada lleva pin. `doctor`
+   muestra la versión detectada y **avisa** si difiere de la probada.
+2. **`validate` después de `generate`**: `run` ejecuta el `validate` del propio
+   repo2rlenv sobre el corpus recién sintetizado y aborta si el formato no
+   cierra (exit 1).
+3. **Calibración oracle/nop como red final**: aunque el formato pase, un cambio
+   de comportamiento upstream que rompa los rewards cae en el gate — oracle
+   que no llega a ~1.0 o nop que no da 0.0 abortan el run (exits 3–5).
+
+Para adoptar una versión nueva: instalarla, re-correr `dream-cycle run` contra
+un repo conocido, y si el gate pasa, actualizar el pin (README) y
+`R2E_TESTED_VERSION` (lib/doctor.mjs).
+
+## Subcomandos
+
+### `dream-cycle doctor [--json]`
+
+Diagnostica node (≥20), docker (CLI + daemon), gh (CLI + auth), harbor y
+repo2rlenv. Exit 0 si todo está, 1 si falta algo.
+
+### `dream-cycle run <owner/repo> [--limit N] [--since YYYY-MM-DD]`
+
+Pipeline completo contra cualquier repo. `--since` es el guardarraíl de
+contaminación: solo se minan PRs posteriores a esa fecha (default `2026-02-01`).
+
+```bash
+dream-cycle run astral-sh/ruff --limit 20 --since 2026-02-01
+```
+
+| Exit | Significado |
+|---|---|
+| 0 | éxito |
+| 1 | subproceso/genérico (generate/validate fallaron, binarios faltantes) |
+| 2 | error de uso |
+| 3 | corpus insuficiente (< minTasks tareas antes o después de curar) |
+| 4 | gate oracle FALLÓ tras curación — investigar |
+| 5 | el gate PASÓ con el agente nulo — el corpus NO discrimina |
+
+### `dream-cycle radar [--runs-dir <dir>] [--benchmark <name>] [--epsilon <n>] [--target <reward>]`
+
+Radar reactivo: compara los result.json del gate entre runs y declara gaps
+(`regression`, `stagnation`, `capability_gap`, `coverage_gap`, `trust_gap`)
+con un borrador de issue cada uno. Exit 1 = hay gaps (señal, no error).
+
+### `dream-cycle init`
+
+Crea `.dream-cycle/` con `config.json` (defaults), `corpus/`, `jobs/`, `runs/`
+y un `.gitignore`. Idempotente: nunca pisa un config existente. **No es
+prerequisito** — sin config todo funciona con los defaults.
+
+## `.dream-cycle/` y qué se commitea
+
+```
+.dream-cycle/
+├── config.json    # SÍ se commitea (paths, bins, defaults del proyecto)
+├── .gitignore     # ignora los tres de abajo
+├── corpus/        # artefactos locales — NO
+├── jobs/          # jobs harbor — NO
+└── runs/          # result.json del gate — decide el humano (sirven de historial del radar)
+```
+
+## Protocolo de honestidad
+
+- **Curación declarada**: las tareas inevaluables (oracle < 0.999 o sin reward)
+  se excluyen, pero la exclusión queda VISIBLE en `tasksExcluded` del result.json
+  y cambia el `corpusVersion` (que se calcula sobre el set efectivo).
+- **Falsificación nop obligatoria**: un corpus solo vale si el agente nulo lo
+  FALLA. Si el nop pasa, el corpus no discrimina y el pipeline aborta (exit 5).
+- **Targets antes de resultados**: el gate en modo agent se NIEGA a gatear sin
+  un `--target-reward-mean` declarado por el invocador (anti-fabricación).
+- **El radar propone, el humano decide**: los `issueDraft` requieren revisión
+  humana antes de abrirse; el radar nunca abre issues ni decide qué construir.
+
+## Seguridad
+
+- **NUNCA tokens en archivos**: el overlay de compose para repos privados solo
+  contiene el placeholder literal `${GITHUB_TOKEN}`; compose lo interpola desde
+  el entorno del proceso. El token jamás toca disco.
+- Nota: un build-arg queda visible en los metadatos de la imagen local
+  (`docker history`); aceptable para runs locales — **no publicar esas imágenes**.
+- El brazo agente opcional con claude-code se invoca a mano con placeholder:
+
+```bash
+harbor run -p <corpus> -a claude-code -m <model> \
+  --ae CLAUDE_CODE_OAUTH_TOKEN=<token> --ae CLAUDE_FORCE_OAUTH=1 \
+  --env docker -o <jobs>/dc-<slug>-agent
+```
+
+## Licencia
+
+MIT

package/bin/dream-cycle.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// dream-cycle.mjs — dispatcher CLI del paquete dream-cycle.
+//
+// ÚNICO lugar del paquete que llama process.exit: las lib/* retornan exit codes
+// o lanzan UsageError (uso, exit 2) / PipelineError (exit = code del error).
+
+import { readFileSync } from 'node:fs';
+import { UsageError, PipelineError } from '../lib/config.mjs';
+
+const HELP = `uso: dream-cycle <comando> [opciones]
+
+comandos:
+  doctor [--json]
+      verifica dependencias externas (node, docker, gh, harbor, repo2rlenv)
+
+  run <owner/repo> [--limit N] [--since YYYY-MM-DD]
+      pipeline completo: sintetizar (pr_diff) → endurecer → calibrar
+      (oracle+nop) → curar → gate → radar
+
+  radar [--runs-dir <dir>] [--benchmark <name>] [--epsilon <n>] [--target <reward>]
+      radar reactivo sobre el historial de result.json del gate
+      (RADAR_JSON=1 para JSON, RADAR_NO_WRITE=1 para no escribir)
+
+  init
+      crea .dream-cycle/ (config.json, corpus/, jobs/, runs/) — idempotente
+
+  --version | --help
+
+exit codes de run:
+  0 éxito · 1 subproceso/genérico · 2 uso · 3 corpus insuficiente ·
+  4 gate oracle falló · 5 el agente nulo pasó (el corpus no discrimina)`;
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+
+  if (cmd === '--version' || cmd === '-v') {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+    console.log(pkg.version);
+    return 0;
+  }
+  if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
+    console.log(HELP);
+    return 0;
+  }
+
+  const ctx = { argv: rest, cwd: process.cwd(), env: process.env };
+  switch (cmd) {
+    case 'doctor': return (await import('../lib/doctor.mjs')).doctorCli(ctx);
+    case 'run': return (await import('../lib/run.mjs')).runCli(ctx);
+    case 'radar': return (await import('../lib/radar.mjs')).radarCli(ctx);
+    case 'init': return (await import('../lib/init.mjs')).initCli(ctx);
+    default:
+      console.error(HELP);
+      return 2;
+  }
+}
+
+try {
+  process.exit(await main());
+} catch (e) {
+  if (e instanceof UsageError) {
+    console.error(`dream-cycle: ${e.message}`);
+    process.exit(2);
+  }
+  if (e instanceof PipelineError) {
+    console.error(`dream-cycle: ${e.message}`);
+    process.exit(e.code);
+  }
+  console.error(e?.stack ?? String(e));
+  process.exit(1);
+}

package/lib/config.mjs

@@ -0,0 +1,109 @@
+// config.mjs — carga/resolución de config, rutas y binarios del paquete dream-cycle.
+//
+// Sin .dream-cycle/config.json todo funciona con DEFAULT_CONFIG: init NO es
+// prerequisito. Los paths del config son relativos al cwd del host y se resuelven
+// a absolutos aquí. Los binarios externos se resuelven en orden:
+//   env (REPO2RLENV_BIN/HARBOR_BIN/GH_BIN/DOCKER_BIN) → config.bins.<name> → PATH → null
+
+import { readFileSync, accessSync, constants, existsSync } from 'node:fs';
+import { join, resolve, isAbsolute, delimiter } from 'node:path';
+
+// ── Errores compartidos (las lib/* lanzan; SOLO bin/ llama process.exit) ──
+export class UsageError extends Error {}
+export class PipelineError extends Error {
+  constructor(message, code = 1) {
+    super(message);
+    this.code = code;
+  }
+}
+
+export const DEFAULT_CONFIG = {
+  version: 1,
+  paths: {
+    corpusDir: '.dream-cycle/corpus',
+    jobsDir: '.dream-cycle/jobs',
+    runsDir: '.dream-cycle/runs',
+  },
+  bins: { repo2rlenv: null, harbor: null, gh: null, docker: null },
+  defaults: {
+    limit: 20,
+    since: '2026-02-01', // guardarraíl de contaminación: solo PRs post-cutoff
+    benchmark: 'repo2rlenv-capability',
+    epsilon: 0.01,
+    target: null,
+    minTasks: 3,
+    oracleThreshold: 0.999,
+  },
+};
+
+// Variable de entorno que puede pisar cada binario del config
+const BIN_ENV_VARS = {
+  repo2rlenv: 'REPO2RLENV_BIN',
+  harbor: 'HARBOR_BIN',
+  gh: 'GH_BIN',
+  docker: 'DOCKER_BIN',
+};
+
+// Merge profundo de objetos planos (arrays y escalares se reemplazan)
+function deepMerge(base, over) {
+  for (const [k, v] of Object.entries(over ?? {})) {
+    if (v && typeof v === 'object' && !Array.isArray(v)
+      && base[k] && typeof base[k] === 'object' && !Array.isArray(base[k])) {
+      deepMerge(base[k], v);
+    } else {
+      base[k] = v;
+    }
+  }
+  return base;
+}
+
+// ── Config ──
+export function loadConfig(cwd) {
+  const configPath = join(cwd, '.dream-cycle', 'config.json');
+  if (!existsSync(configPath)) {
+    return { config: structuredClone(DEFAULT_CONFIG), configPath, exists: false };
+  }
+  let user;
+  try {
+    user = JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch (e) {
+    throw new UsageError(`config.json inválido (${configPath}): ${e.message}`);
+  }
+  return { config: deepMerge(structuredClone(DEFAULT_CONFIG), user), configPath, exists: true };
+}
+
+export function resolvePaths(config, cwd) {
+  const p = config?.paths ?? DEFAULT_CONFIG.paths;
+  return {
+    corpusDir: resolve(cwd, p.corpusDir ?? DEFAULT_CONFIG.paths.corpusDir),
+    jobsDir: resolve(cwd, p.jobsDir ?? DEFAULT_CONFIG.paths.jobsDir),
+    runsDir: resolve(cwd, p.runsDir ?? DEFAULT_CONFIG.paths.runsDir),
+  };
+}
+
+// ── Binarios ──
+// which() casero: escanea env.PATH y devuelve la primera ruta ejecutable (o null).
+// Acepta también rutas absolutas (verifica X_OK directamente).
+export function which(cmd, env) {
+  if (!cmd) return null;
+  if (isAbsolute(cmd)) {
+    try { accessSync(cmd, constants.X_OK); return cmd; } catch { return null; }
+  }
+  for (const dir of (env?.PATH ?? '').split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, cmd);
+    try { accessSync(candidate, constants.X_OK); return candidate; } catch { /* siguiente */ }
+  }
+  return null;
+}
+
+// Orden de resolución: env var → config.bins.<name> → PATH → null
+export function resolveBin(name, config, env) {
+  const candidates = [env?.[BIN_ENV_VARS[name]], config?.bins?.[name], name];
+  for (const c of candidates) {
+    if (!c) continue;
+    const found = which(c, env);
+    if (found) return found;
+  }
+  return null;
+}

package/lib/doctor.mjs

@@ -0,0 +1,150 @@
+// doctor.mjs — detección de dependencias externas del Dream Cycle.
+//
+// El doctor NUNCA crashea: toda invocación externa va en try/catch con timeout.
+// Reporta found/path/version por dependencia, warnings (daemon caído, gh sin
+// auth) y hints accionables cuando falta algo.
+
+import { execFileSync } from 'node:child_process';
+import { loadConfig, resolveBin, UsageError } from './config.mjs';
+
+const EXEC_OPTS = { timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8' };
+
+// Última versión de repo2rlenv contra la que se validó el pipeline E2E.
+// Actualizar tras re-correr `dream-cycle run` completo con una versión nueva.
+const R2E_TESTED_VERSION = '0.8.3';
+
+// repo2rlenv mina PRs con `gh pr list --json baseRefOid`; ese campo existe
+// desde gh 2.49 — con gh anterior el minado falla con "Unknown JSON field".
+const GH_MIN_VERSION = '2.49.0';
+
+// Compara versiones "X.Y.Z": negativo si a < b
+function cmpVersions(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) - (pb[i] ?? 0);
+  }
+  return 0;
+}
+
+// Ejecuta <bin> <args> y devuelve { ok, out } — jamás lanza
+function tryExec(bin, args) {
+  try {
+    return { ok: true, out: (execFileSync(bin, args, EXEC_OPTS) ?? '').toString().trim() };
+  } catch {
+    return { ok: false, out: '' };
+  }
+}
+
+function firstLine(s) {
+  return s ? s.split('\n')[0].trim() : null;
+}
+
+export function runDoctor({ cwd, env }) {
+  const { config } = loadConfig(cwd);
+  const checks = [];
+
+  // node — el propio runtime; found si major >= 20 (engines del paquete)
+  const major = Number(process.version.slice(1).split('.')[0]);
+  checks.push({
+    name: 'node', required: true, found: major >= 20,
+    path: process.execPath, version: process.version, warning: null,
+    hint: major >= 20 ? null : 'dream-cycle requiere Node >= 20 — actualiza tu runtime',
+  });
+
+  // docker — CLI + daemon (daemon caído = warning, no FALTA)
+  const dockerBin = resolveBin('docker', config, env);
+  const docker = { name: 'docker', required: true, found: false, path: dockerBin, version: null, warning: null, hint: null };
+  if (dockerBin) {
+    const v = tryExec(dockerBin, ['--version']);
+    docker.found = v.ok;
+    docker.version = v.ok ? firstLine(v.out) : null;
+    if (v.ok && !tryExec(dockerBin, ['info']).ok) {
+      docker.warning = 'CLI encontrado pero daemon inalcanzable';
+    }
+  }
+  if (!docker.found) docker.hint = 'instala Docker o exporta DOCKER_BIN=/ruta/al/binario';
+  checks.push(docker);
+
+  // gh — CLI + autenticación (sin auth = warning: repos privados no funcionarán)
+  const ghBin = resolveBin('gh', config, env);
+  const gh = { name: 'gh', required: true, found: false, path: ghBin, version: null, warning: null, hint: null };
+  if (ghBin) {
+    const v = tryExec(ghBin, ['--version']);
+    gh.found = v.ok;
+    gh.version = v.ok ? firstLine(v.out) : null;
+    const warnings = [];
+    const semver = gh.version?.match(/(\d+\.\d+\.\d+)/)?.[1];
+    if (semver && cmpVersions(semver, GH_MIN_VERSION) < 0) {
+      warnings.push(`gh ${semver} < ${GH_MIN_VERSION} — el minado pr_diff fallará (campo baseRefOid); actualiza gh`);
+    }
+    if (v.ok && !tryExec(ghBin, ['auth', 'token']).ok) {
+      warnings.push('gh sin autenticar — repos privados no funcionarán');
+    }
+    if (warnings.length) gh.warning = warnings.join(' · ');
+  }
+  if (!gh.found) gh.hint = 'instala GitHub CLI (gh) o exporta GH_BIN=/ruta/al/binario';
+  checks.push(gh);
+
+  // harbor — --version con fallback a --help (versiones viejas no exponen --version)
+  const harborBin = resolveBin('harbor', config, env);
+  const harbor = { name: 'harbor', required: true, found: false, path: harborBin, version: null, warning: null, hint: null };
+  if (harborBin) {
+    const v = tryExec(harborBin, ['--version']);
+    if (v.ok) {
+      harbor.found = true;
+      harbor.version = firstLine(v.out);
+    } else {
+      harbor.found = tryExec(harborBin, ['--help']).ok;
+    }
+  }
+  if (!harbor.found) harbor.hint = 'instala harbor (uv tool install harbor — está en PyPI) o exporta HARBOR_BIN=/ruta/al/binario';
+  checks.push(harbor);
+
+  // repo2rlenv — --version con fallback a --help; avisa si la versión difiere
+  // de la probada (releases frecuentes upstream: validate + gate son la red real)
+  const r2eBin = resolveBin('repo2rlenv', config, env);
+  const r2e = { name: 'repo2rlenv', required: true, found: false, path: r2eBin, version: null, warning: null, hint: null };
+  if (r2eBin) {
+    const v = tryExec(r2eBin, ['--version']);
+    if (v.ok) {
+      r2e.found = true;
+      r2e.version = firstLine(v.out);
+      if (!r2e.version.includes(R2E_TESTED_VERSION)) {
+        r2e.warning = `versión distinta de la probada (${R2E_TESTED_VERSION}) — si \`run\` falla, prueba: uv tool install repo2rlenv==${R2E_TESTED_VERSION}`;
+      }
+    } else {
+      r2e.found = tryExec(r2eBin, ['--help']).ok;
+    }
+  }
+  if (!r2e.found) r2e.hint = 'instala repo2rlenv (uv tool install repo2rlenv — requiere Python >= 3.12) o exporta REPO2RLENV_BIN=/ruta/al/binario';
+  checks.push(r2e);
+
+  const ok = checks.every((c) => !c.required || c.found);
+  return { ok, checks };
+}
+
+export function doctorCli({ argv, cwd, env }) {
+  let json = false;
+  for (const a of argv) {
+    if (a === '--json') json = true;
+    else throw new UsageError(`doctor: argumento desconocido ${a}`);
+  }
+
+  const result = runDoctor({ cwd, env });
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log('# dream-cycle doctor');
+    for (const c of result.checks) {
+      const status = c.found ? 'OK   ' : 'FALTA';
+      const ver = c.version ? ` (${c.version})` : '';
+      console.log(`  ${status} ${c.name.padEnd(12)} ${c.path ?? '-'}${ver}`);
+      if (c.warning) console.log(`        aviso: ${c.warning}`);
+      if (c.hint) console.log(`        sugerencia: ${c.hint}`);
+    }
+    console.log(result.ok ? 'todo listo' : 'faltan dependencias — el pipeline `run` no funcionará completo');
+  }
+  return result.ok ? 0 : 1;
+}

package/lib/gate.mjs

@@ -0,0 +1,289 @@
+// gate.mjs — Gate de capacidad F2 (BLUEPRINT-008 §F2, ADR-002).
+// Vendorizado de scripts/repo2rlenv-capability-harness.mjs @ 89641e3 (2026-06-11).
+// El original NO se toca; sincronizar manualmente si diverge.
+//
+// Integración por artefactos (BLUEPRINT-008 §4.2): NO corre el agente ni calcula
+// rewards — agrega los /logs/verifier/reward.json que el verifier de cada tarea
+// escribió en un job Harbor terminado, los cruza contra el corpus versionado y
+// emite result.json con gate.checks.
+//
+// Cambios respecto del original (y NADA más):
+//   (a) RUNS_DIR: env.RUNS_DIR → opts.runsDir → default del config
+//   (b) die() lanza UsageError en vez de process.exit(2)
+//   (c) main() → runGate(opts) que RETORNA el summary
+//   (d) sin auto-ejecución al final del módulo
+//
+//   BENCH_JSON=1      solo JSON a stdout
+//   BENCH_NO_WRITE=1  no escribe archivos
+//
+// Targets (fijados ANTES de cualquier run — protocolo de honestidad):
+//   oracle: rewardMean ≥ 0.999 (REWARD_SCHEMA: "Gold patch → 1.0"), coverage = 1,
+//           resolvedRate = 1 sobre tareas runtime, 0 tareas no confiables.
+//   agent:  coverage = 1 + target de reward DECLARADO por el invocador; sin
+//           targetRewardMean el gate se NIEGA a gatear (anti-fabricación).
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { join, resolve, basename, dirname, sep } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { loadConfig, resolvePaths, UsageError } from './config.mjs';
+
+export const BENCH_NAME = 'repo2rlenv-capability';
+// Cotas de calibración por construcción (no hay paper para un corpus propio):
+const CALIBRATION = {
+  oracleExpected: 1.0,
+  nullAgentExpected: 0.0,
+  source: 'Repo2RLEnv docs/reference/REWARD_SCHEMA.md ("Gold patch -> 1.0") + BLUEPRINT-008 §2.1',
+};
+
+// ── CLI ──
+export function parseGateArgs(argv) {
+  const a = { jobs: [], corpora: [], mode: null, targetRewardMean: null, targetCostUsd: null, agentLabel: null, exclude: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const k = argv[i], v = argv[i + 1];
+    if (k === '--job') { a.jobs.push(resolve(v)); i++; }
+    else if (k === '--corpus') { a.corpora.push(resolve(v)); i++; }
+    else if (k === '--exclude') { a.exclude.push(v); i++; } // curación VISIBLE: queda en tasksExcluded del result
+    else if (k === '--mode') { a.mode = v; i++; }
+    else if (k === '--target-reward-mean') { a.targetRewardMean = Number(v); i++; }
+    else if (k === '--target-cost-usd') { a.targetCostUsd = Number(v); i++; }
+    else if (k === '--agent-label') { a.agentLabel = v; i++; }
+    else die(`argumento desconocido: ${k}`);
+  }
+  if (!a.jobs.length || !a.corpora.length) die('uso: --job <dir> --corpus <dir> --mode oracle|agent');
+  if (!['oracle', 'agent'].includes(a.mode)) die('--mode debe ser oracle|agent');
+  if (a.mode === 'agent' && !(a.targetRewardMean > 0))
+    die('modo agent sin --target-reward-mean: me niego a gatear sin un target declarado (anti-fabricación, ADR-002 pregunta 4)');
+  return a;
+}
+function die(msg) { throw new UsageError(`repo2rlenv-capability-harness: ${msg}`); }
+
+// ── Corpus: task.toml → {id, contentHash, pipeline, rewardKind} ──
+function walk(dir, found = []) {
+  for (const e of readdirSync(dir)) {
+    const p = join(dir, e);
+    const st = statSync(p);
+    if (st.isDirectory()) walk(p, found);
+    else found.push(p);
+  }
+  return found;
+}
+function tomlStr(src, key) {
+  const m = src.match(new RegExp(`^${key}\\s*=\\s*"([^"]*)"`, 'm'));
+  return m ? m[1] : null;
+}
+function loadCorpus(corpora) {
+  const tasks = [];
+  for (const dir of corpora) {
+    for (const f of walk(dir).filter((p) => basename(p) === 'task.toml')) {
+      const src = readFileSync(f, 'utf-8');
+      const name = tomlStr(src, 'name') ?? '';
+      const id = name.includes('/') ? name.split('/').pop() : basename(join(f, '..'));
+      tasks.push({
+        id,
+        dirBase: basename(join(f, '..')),
+        contentHash: tomlStr(src, 'content_hash'),
+        pipeline: tomlStr(src, 'pipeline'),
+        rewardKind: /test_execution/.test(src) ? 'test_execution' : 'diff_similarity',
+      });
+    }
+  }
+  if (!tasks.length) die('corpus vacío: ningún task.toml encontrado');
+  const dup = tasks.map((t) => t.id).filter((id, i, all) => all.indexOf(id) !== i);
+  if (dup.length) die(`ids de tarea duplicados en el corpus: ${[...new Set(dup)].join(', ')}`);
+  return tasks;
+}
+function corpusVersion(tasks) {
+  const hashes = tasks.map((t) => t.contentHash ?? `MISSING:${t.id}`).sort();
+  return 'sha256:' + createHash('sha256').update(hashes.join('\n')).digest('hex');
+}
+
+// ── Job Harbor: localizar reward.json/reward.txt por tarea ──
+// Match por config.json del trial (task.path → dir original): Harbor TRUNCA el
+// nombre del trial a 32 chars (wiki-138/wiki-139 colapsan a wiki-13__xxx), así
+// que el nombre de directorio es ambiguo. config.json es la fuente no ambigua.
+// Fallback a segMatches por compatibilidad con jobs viejos sin config legible.
+function segMatches(seg, key) {
+  if (seg === key) return true;
+  if (!seg.startsWith(key)) return false;
+  return !/[a-zA-Z0-9]/.test(seg[key.length]); // borde: evita RuVector-41 ⊂ RuVector-419
+}
+function trialDirFor(rewardPath) {
+  // .../<trial>/verifier/reward.json → .../<trial>
+  return dirname(dirname(rewardPath));
+}
+function taskPathOfTrial(trialDir) {
+  const cfg = join(trialDir, 'config.json');
+  if (!existsSync(cfg)) return null;
+  try { return JSON.parse(readFileSync(cfg, 'utf-8'))?.task?.path ?? null; } catch { return null; }
+}
+function rewardsByTask(jobs, tasks) {
+  const files = jobs.flatMap((j) => walk(j)).filter((p) => /reward\.(json|txt)$/.test(basename(p)));
+  const byTask = new Map();
+  for (const t of tasks) {
+    const keys = [...new Set([t.id, t.dirBase])];
+    const mine = files.filter((p) => {
+      const tp = taskPathOfTrial(trialDirFor(p));
+      if (tp) return basename(tp) === t.dirBase;                 // match no ambiguo
+      return p.split(sep).some((seg) => keys.some((k) => segMatches(seg, k))); // fallback
+    });
+    const jsons = mine.filter((p) => p.endsWith('reward.json'));
+    byTask.set(t.id, jsons.length ? jsons : mine.filter((p) => p.endsWith('reward.txt')));
+  }
+  return byTask;
+}
+function readReward(path) {
+  if (path.endsWith('reward.txt')) return { reward: Number(readFileSync(path, 'utf-8').trim()) };
+  const r = JSON.parse(readFileSync(path, 'utf-8'));
+  // El verifier pr_diff desplegado escribe `final_reward`; REWARD_SCHEMA.md documenta
+  // `reward` (runtime). Aceptar ambos — sin esto el pr_diff agrega 0 en silencio.
+  if (r.reward === undefined && typeof r.final_reward === 'number') r.reward = r.final_reward;
+  return r;
+}
+
+// ── Agregación ──
+function aggregate(tasks, byTask) {
+  const perTask = [];
+  const missing = [];
+  for (const t of tasks) {
+    const files = byTask.get(t.id);
+    if (!files.length) { missing.push(t.id); continue; }
+    const rewards = files.map(readReward);
+    const r = rewards[rewards.length - 1]; // múltiples trials: reporta el último, media en `reward`
+    const reward = rewards.reduce((s, x) => s + (x.reward ?? 0), 0) / rewards.length;
+    perTask.push({
+      task: t.id,
+      contentHash: t.contentHash,
+      rewardKind: t.rewardKind,
+      reward: Number(reward.toFixed(6)),
+      trials: rewards.length,
+      resolved: r.resolved ?? null,
+      judgeStatus: r.judge_status ?? null,
+      capped: r.capped ?? null,
+      parseStatus: r.parse_status ?? null,
+      evalTrustworthy: r.eval_trustworthy ?? (r.parse_status ? r.parse_status === 'ok' : null),
+    });
+  }
+  const n = perTask.length;
+  const sum = perTask.reduce((s, p) => s + p.reward, 0);
+  const runtime = perTask.filter((p) => p.rewardKind === 'test_execution');
+  const untrusted = perTask.filter((p) => p.evalTrustworthy === false);
+  return {
+    perTask,
+    missing,
+    metrics: {
+      reward: {
+        mean: n ? Number((sum / n).toFixed(6)) : null,
+        meanPessimistic: Number((sum / tasks.length).toFixed(6)), // faltantes cuentan 0
+        min: n ? Math.min(...perTask.map((p) => p.reward)) : null,
+        max: n ? Math.max(...perTask.map((p) => p.reward)) : null,
+      },
+      resolvedRate: runtime.length
+        ? Number((runtime.filter((p) => p.resolved === true).length / runtime.length).toFixed(6))
+        : null,
+      coverage: Number((n / tasks.length).toFixed(6)),
+      untrustedCount: untrusted.length,
+    },
+    deterministic: perTask.every((p) => p.judgeStatus !== 'ok'), // ningún juez LLM contribuyó
+    judgeSummary: perTask.reduce((acc, p) => {
+      if (p.judgeStatus) acc[p.judgeStatus] = (acc[p.judgeStatus] ?? 0) + 1;
+      return acc;
+    }, {}),
+  };
+}
+
+// ── Gate (targets fijados arriba, antes de ver resultados) ──
+function gateChecks(mode, m, args) {
+  const checks = [];
+  checks.push([`coverage >= 1`, m.coverage >= 1]);
+  if (mode === 'oracle') {
+    checks.push([`reward.mean >= 0.999 (oráculo: gold patch ⇒ 1.0)`, m.reward.mean !== null && m.reward.mean >= 0.999]);
+    if (m.resolvedRate !== null) checks.push([`resolvedRate >= 1 (runtime)`, m.resolvedRate >= 1]);
+    checks.push([`untrustedCount == 0`, m.untrustedCount === 0]);
+  } else {
+    checks.push([`reward.mean >= ${args.targetRewardMean} (target declarado)`,
+      m.reward.mean !== null && m.reward.mean >= args.targetRewardMean]);
+  }
+  return checks;
+}
+
+// ── Núcleo (ex-main): agrega, gatea y RETORNA el summary ──
+export function runGate(opts) {
+  const t0 = performance.now();
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const args = {
+    jobs: [], corpora: [], mode: null, targetRewardMean: null,
+    targetCostUsd: null, agentLabel: null, exclude: [], ...opts,
+  };
+  if (!args.jobs.length || !args.corpora.length) die('uso: --job <dir> --corpus <dir> --mode oracle|agent');
+  if (!['oracle', 'agent'].includes(args.mode)) die('--mode debe ser oracle|agent');
+  if (args.mode === 'agent' && !(args.targetRewardMean > 0))
+    die('modo agent sin --target-reward-mean: me niego a gatear sin un target declarado (anti-fabricación, ADR-002 pregunta 4)');
+
+  // Precedencia runs-dir: env.RUNS_DIR > opts.runsDir > default del config
+  const runsDir = env.RUNS_DIR
+    ? resolve(cwd, env.RUNS_DIR)
+    : (opts.runsDir ?? resolvePaths(loadConfig(cwd).config, cwd).runsDir);
+
+  const allTasks = loadCorpus(args.corpora);
+  const unknownExcl = args.exclude.filter((e) => !allTasks.some((t) => t.id === e));
+  if (unknownExcl.length) die(`--exclude no matchea el corpus: ${unknownExcl.join(', ')}`);
+  const tasks = allTasks.filter((t) => !args.exclude.includes(t.id));
+  if (!tasks.length) die('todas las tareas excluidas');
+  const agg = aggregate(tasks, rewardsByTask(args.jobs, tasks));
+  const checks = gateChecks(args.mode, agg.metrics, args);
+  const passed = checks.filter(([, ok]) => ok).length;
+
+  const summary = {
+    runAt: new Date().toISOString(),
+    benchmark: BENCH_NAME,
+    mode: args.mode,
+    agent: args.agentLabel ?? (args.mode === 'oracle' ? 'oracle (gold patch)' : 'undeclared'),
+    corpusVersion: corpusVersion(tasks), // cambia si cambia el set efectivo (exclusiones incluidas)
+    corpusSize: tasks.length,
+    tasksExcluded: args.exclude,
+    corpora: args.corpora,
+    jobDirs: args.jobs,
+    calibration: CALIBRATION,
+    metrics: agg.metrics,
+    deterministic: agg.deterministic,
+    judgeSummary: agg.judgeSummary,
+    costUsd: null, // eje bench: el job dir del oráculo no trae costo/latencia por tarea — declarado, no inventado
+    latencyMs: { harness: Number((performance.now() - t0).toFixed(2)), perTask: null },
+    perTask: agg.perTask,
+    tasksMissing: agg.missing,
+    gate: { passed, total: checks.length, allPass: passed === checks.length,
+            checks: checks.map(([label, ok]) => ({ label, ok })) },
+  };
+
+  if (!opts.quiet) {
+    if (opts.json || env.BENCH_JSON) console.log(JSON.stringify(summary, null, 2));
+    else {
+      console.log(`# ${BENCH_NAME} | mode: ${args.mode} | agent: ${summary.agent} | corpus ${summary.corpusVersion.slice(0, 18)}… (${tasks.length} tareas)`);
+      for (const [l, ok] of checks) console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${l}`);
+      console.log(`reward.mean=${agg.metrics.reward.mean} resolvedRate=${agg.metrics.resolvedRate} coverage=${agg.metrics.coverage} | ${passed}/${checks.length} targets`);
+      if (agg.missing.length) console.log(`tareas sin reward en el job: ${agg.missing.join(', ')}`);
+    }
+  }
+
+  if (!(opts.noWrite || env.BENCH_NO_WRITE)) {
+    mkdirSync(runsDir, { recursive: true });
+    const stamp = summary.runAt.replace(/[:.]/g, '-');
+    writeFileSync(join(runsDir, `${BENCH_NAME}-${stamp}.json`), JSON.stringify(summary, null, 2));
+    writeFileSync(join(runsDir, `${BENCH_NAME}-latest.json`), JSON.stringify(summary, null, 2));
+  }
+  return summary;
+}
+
+// gate NO es subcomando del bin — gateCli existe solo para uso programático
+export function gateCli({ argv, cwd, env }) {
+  let summary;
+  try {
+    summary = runGate({ ...parseGateArgs(argv), cwd, env });
+  } catch (e) {
+    if (e instanceof UsageError) { console.error(e.message); return 2; }
+    throw e;
+  }
+  return summary.gate.allPass ? 0 : 1;
+}

package/lib/harden.mjs

@@ -0,0 +1,38 @@
+// harden.mjs — endurecimiento de Dockerfiles para repos privados.
+// Port del patch python de scripts/dream-cycle.sh (líneas 51-63), hallazgo
+// upstream 2026-06-11: Repo2RLEnv quita el token de la URL remota ANTES del
+// fetch/reset; con --filter=blob:none en repo privado los blobs lazy dan
+// 401 → exit 128. Fix: mover el set-url (que quita el token) a después del
+// reset. Idempotente: si el patrón ya no está, se salta el archivo.
+
+import { readFileSync, writeFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function hardenDockerfiles(corpusDir, log = console.log) {
+  const hardened = [];
+  if (!existsSync(corpusDir)) return hardened;
+
+  for (const task of readdirSync(corpusDir)) {
+    const dockerfile = join(corpusDir, task, 'environment', 'Dockerfile');
+    let st;
+    try { st = statSync(dockerfile); } catch { continue; }
+    if (!st.isFile()) continue;
+
+    let s = readFileSync(dockerfile, 'utf-8');
+    const m = s.match(/ \\\n && git -C \/workspace remote set-url origin (\S+)\n/);
+    if (!m) continue; // ya parcheado o formato distinto (idempotencia)
+
+    const url = m[1];
+    s = s.replace(m[0], '\n');
+    // replacer-FUNCIÓN obligatoria: la URL puede contener `$` y un string de
+    // reemplazo lo interpretaría como patrón especial ($&, $1, ...)
+    s = s.replace(
+      /(RUN git reset --hard \S+ \\\n && git clean [^\n]+)\n/,
+      (_, g1) => g1 + ' \\\n && git remote set-url origin ' + url + '\n',
+    );
+    writeFileSync(dockerfile, s);
+    hardened.push(task);
+    log(`  endurecido: ${task}`);
+  }
+  return hardened;
+}

package/lib/init.mjs

@@ -0,0 +1,41 @@
+// init.mjs — escribe .dream-cycle/config.json idempotente.
+//
+// init NO es prerequisito (todo funciona con DEFAULT_CONFIG); solo materializa
+// el esqueleto para quien quiera personalizar paths/bins/defaults. Idempotente:
+// jamás pisa un config.json ni un .gitignore existentes.
+
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_CONFIG, UsageError } from './config.mjs';
+
+export function runInit({ cwd }) {
+  const base = join(cwd, '.dream-cycle');
+  const configPath = join(base, 'config.json');
+
+  // dirs de trabajo (mkdir recursivo es idempotente por sí mismo)
+  for (const d of [base, join(base, 'corpus'), join(base, 'jobs'), join(base, 'runs')]) {
+    mkdirSync(d, { recursive: true });
+  }
+
+  let created = false;
+  if (!existsSync(configPath)) {
+    writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + '\n');
+    created = true;
+  }
+
+  // corpus/jobs/runs son artefactos locales — fuera del control de versiones
+  const gitignorePath = join(base, '.gitignore');
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, 'corpus/\njobs/\nruns/\n');
+  }
+
+  return { configPath, created };
+}
+
+export function initCli({ argv, cwd }) {
+  for (const a of argv) throw new UsageError(`init: argumento desconocido ${a}`);
+  const { configPath, created } = runInit({ cwd });
+  if (created) console.log(`config creada: ${configPath}`);
+  else console.log(`config existente, sin cambios: ${configPath}`);
+  return 0;
+}

package/lib/radar.mjs

@@ -0,0 +1,145 @@
+// radar.mjs — Dream Cycle v0: radar REACTIVO sobre los result.json del gate.
+// Vendorizado de scripts/dream-cycle-radar.mjs @ 89641e3 (2026-06-11).
+// El original NO se toca; sincronizar manualmente si diverge.
+//
+// Decisión (memoria dream-cycle-feasibility, 2026-06-10): nada de cron nocturno ni
+// módulo; el radar es la comparación entre corridas del gate de capacidad. Detecta
+// y DECLARA gaps — no decide qué construir (ADR-001 "Deliberately NOT #3": el paso
+// 3 es humano; el radar propone, el humano dispone).
+//
+// Series comparables = mismo (benchmark, corpusVersion, mode, agent). Sobre cada una:
+//   regression      reward.mean cae > epsilon vs run anterior
+//   stagnation      ≥3 runs sin mejora y bajo target (si hay target declarado)
+//   capability_gap  último run bajo target → lista tareas con reward < 0.5 (estilo #2156)
+//   coverage_gap    tasksMissing no vacío en el último run
+//   trust_gap       untrustedCount > 0 en el último run
+//
+// Salida: reporte JSON (+ borrador de issue por gap) y exit 1 si hay gaps (señal),
+// 0 si todo limpio. El humano convierte borradores en issues; el radar nunca los abre.
+//
+// Cambio ÚNICO respecto del original: el default de --runs-dir sale del config
+// (.dream-cycle/runs) en vez de docs/research-flow/runs.
+//   RADAR_JSON=1 / RADAR_NO_WRITE=1
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { loadConfig, resolvePaths, UsageError } from './config.mjs';
+
+// ── Núcleo analítico (exportado para tests) ──
+export function analyzeSeries(runs, { epsilon, target }) {
+  const gaps = [];
+  const sorted = [...runs].sort((a, b) => a.runAt.localeCompare(b.runAt));
+  const last = sorted[sorted.length - 1];
+  const id = `${last.benchmark} · ${(last.corpusVersion ?? '').slice(0, 18)} · ${last.mode}/${last.agent}`;
+
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1].metrics?.reward?.mean;
+    const curr = sorted[i].metrics?.reward?.mean;
+    if (prev == null || curr == null) continue;
+    const delta = Number((curr - prev).toFixed(6));
+    if (delta < -epsilon) {
+      gaps.push({
+        type: 'regression', series: id, runAt: sorted[i].runAt, delta,
+        from: prev, to: curr,
+        issueDraft: `[radar] Regresión de capacidad en ${id}: reward.mean ${prev} → ${curr} (Δ ${delta}) entre ${sorted[i - 1].runAt} y ${sorted[i].runAt}. Revisar el diff de ese intervalo y re-correr el gate.`,
+      });
+    }
+  }
+
+  if (target != null) {
+    const lastMean = last.metrics?.reward?.mean;
+    if (lastMean != null && lastMean < target) {
+      const failingTasks = (last.perTask ?? []).filter((p) => (p.reward ?? 0) < 0.5).map((p) => p.task);
+      gaps.push({
+        type: 'capability_gap', series: id, runAt: last.runAt, mean: lastMean, target, failingTasks,
+        issueDraft: `[radar] Gap de capacidad en ${id}: reward.mean ${lastMean} < target ${target}. Tareas que fallan: ${failingTasks.join(', ') || '(ver perTask)'}. Candidato a tema de minado (Repo2RLEnv) o a patrón faltante en el bank.`,
+      });
+    }
+    const tail = sorted.slice(-3);
+    if (tail.length === 3 && tail.every((r) => (r.metrics?.reward?.mean ?? 1) < target)
+      && tail[2].metrics.reward.mean <= tail[0].metrics.reward.mean) {
+      gaps.push({
+        type: 'stagnation', series: id, runAt: last.runAt,
+        means: tail.map((r) => r.metrics.reward.mean),
+        issueDraft: `[radar] Estancamiento en ${id}: 3 runs consecutivos bajo target ${target} sin mejora (${tail.map((r) => r.metrics.reward.mean).join(' → ')}).`,
+      });
+    }
+  }
+
+  if ((last.tasksMissing ?? []).length) {
+    gaps.push({
+      type: 'coverage_gap', series: id, runAt: last.runAt, tasksMissing: last.tasksMissing,
+      issueDraft: `[radar] Cobertura incompleta en ${id}: sin reward para ${last.tasksMissing.join(', ')}. El run no es comparable hasta cubrir el corpus completo.`,
+    });
+  }
+  if ((last.metrics?.untrustedCount ?? 0) > 0) {
+    gaps.push({
+      type: 'trust_gap', series: id, runAt: last.runAt, untrustedCount: last.metrics.untrustedCount,
+      issueDraft: `[radar] ${last.metrics.untrustedCount} tarea(s) con eval no confiable (parse fallback) en ${id}: el reward de esas tareas no significa nada — arreglar el parser/runner antes de comparar.`,
+    });
+  }
+  return gaps;
+}
+
+// ── Reporte (lectura pura: no escribe nada en disco) ──
+export function radarReport({ runsDir, benchmark, epsilon, target }) {
+  const files = readdirSync(runsDir)
+    .filter((f) => f.startsWith(benchmark + '-') && f.endsWith('.json') && !f.includes('latest'));
+  const runs = files.map((f) => {
+    try { return JSON.parse(readFileSync(join(runsDir, f), 'utf-8')); } catch { return null; }
+  }).filter((r) => r && r.runAt && r.metrics);
+
+  const bySeries = new Map();
+  for (const r of runs) {
+    const key = `${r.corpusVersion}|${r.mode}|${r.agent}`;
+    if (!bySeries.has(key)) bySeries.set(key, []);
+    bySeries.get(key).push(r);
+  }
+
+  const gaps = [];
+  for (const series of bySeries.values()) gaps.push(...analyzeSeries(series, { epsilon, target }));
+
+  const report = {
+    runAt: new Date().toISOString(),
+    radar: 'dream-cycle-v0-reactive',
+    runsDir,
+    benchmark,
+    params: { epsilon, target },
+    seriesAnalyzed: bySeries.size,
+    runsAnalyzed: runs.length,
+    gaps,
+    note: 'El radar propone, no decide (ADR-001): los issueDraft requieren revisión humana antes de abrirse.',
+  };
+  return { report, hasGaps: gaps.length > 0 };
+}
+
+// ── CLI ──
+export function radarCli({ argv, cwd, env }) {
+  const { config } = loadConfig(cwd);
+  const args = {
+    runsDir: resolvePaths(config, cwd).runsDir,
+    benchmark: 'repo2rlenv-capability', epsilon: 0.01, target: null,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const k = argv[i], v = argv[i + 1];
+    if (k === '--runs-dir') { args.runsDir = resolve(cwd, v); i++; }
+    else if (k === '--benchmark') { args.benchmark = v; i++; }
+    else if (k === '--epsilon') { args.epsilon = Number(v); i++; }
+    else if (k === '--target') { args.target = Number(v); i++; }
+    else throw new UsageError(`radar: argumento desconocido ${k}`);
+  }
+
+  const { report, hasGaps } = radarReport(args);
+
+  if (env.RADAR_JSON) console.log(JSON.stringify(report, null, 2));
+  else {
+    console.log(`# dream-cycle radar | ${report.seriesAnalyzed} series, ${report.runsAnalyzed} runs`);
+    if (!report.gaps.length) console.log('  sin gaps — todo dentro de baseline');
+    for (const g of report.gaps) console.log(`  [${g.type}] ${g.issueDraft}`);
+  }
+  if (!env.RADAR_NO_WRITE) {
+    mkdirSync(args.runsDir, { recursive: true });
+    writeFileSync(join(args.runsDir, 'dream-cycle-radar-latest.json'), JSON.stringify(report, null, 2));
+  }
+  return hasGaps ? 1 : 0; // exit 1 = hay gaps (señal, no error)
+}

package/lib/run.mjs

@@ -0,0 +1,206 @@
+// run.mjs — pipeline completo del Dream Cycle v0 contra CUALQUIER repo público
+// (port de scripts/dream-cycle.sh @ 89641e3, BLUEPRINT-008 post-F4).
+//
+// Cadena completa, repo-agnóstica (pipeline pr_diff: sin bootstrap Docker pesado,
+// funciona para cualquier lenguaje):
+//   1. SINTETIZAR  repo2rlenv generate pr_diff (post-cutoff, sin LLM)
+//   2. CALIBRAR    harbor oracle (gold ⇒ ~1.0) + nop (nulo ⇒ 0.0)
+//   3. CURAR       tareas inevaluables (oracle < umbral) → exclusiones DECLARADAS
+//   4. GATE        modo oracle (PASS esperado) y nop (debe FALLAR — falsificación)
+//   5. RADAR       radar reactivo sobre el historial de runs
+//
+// El radar propone; el humano decide qué gap atacar (ADR-001 Deliberately-NOT-#3).
+// Divergencia deliberada vs el .sh: sin prepend de ~/.local/tools/gh-latest al
+// PATH — el sustituto es GH_BIN o config.bins.gh.
+//
+// Exit codes: 0 éxito · 1 subproceso/genérico · 2 uso · 3 corpus insuficiente ·
+//             4 gate oracle falló · 5 nop pasó (el corpus no discrimina)
+
+import { existsSync, readdirSync, statSync, mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { loadConfig, resolvePaths, resolveBin, UsageError, PipelineError } from './config.mjs';
+import { hardenDockerfiles } from './harden.mjs';
+import { runGate } from './gate.mjs';
+import { radarReport } from './radar.mjs';
+
+// Subdirectorios de primer nivel (equivalente al `ls -d */` del bash)
+function subdirs(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((e) => {
+    try { return statSync(join(dir, e)).isDirectory(); } catch { return false; }
+  });
+}
+
+export async function runPipeline({ repo, limit, since, cwd, env, log = console.log }) {
+  const { config } = loadConfig(cwd);
+  const defaults = config.defaults;
+  limit = limit ?? defaults.limit;
+  since = since ?? defaults.since; // guardarraíl de contaminación: solo PRs post-cutoff
+  const minTasks = defaults.minTasks;
+
+  const { corpusDir, jobsDir, runsDir } = resolvePaths(config, cwd);
+  const slug = repo.replace('/', '__');
+  const corpus = join(corpusDir, `dc-${slug}`);
+  const oracleJob = join(jobsDir, `dc-${slug}-oracle`);
+  const nopJob = join(jobsDir, `dc-${slug}-nop`);
+
+  // OLLAMA_API_KEY no se usa (pr_diff no necesita LLM) pero harbor lo exige presente
+  const childEnv = {
+    ...env,
+    DOCKER_HOST: env.DOCKER_HOST ?? 'unix:///var/run/docker.sock',
+    OLLAMA_API_KEY: env.OLLAMA_API_KEY ?? 'dummy',
+  };
+
+  const r2eBin = resolveBin('repo2rlenv', config, env);
+  const harborBin = resolveBin('harbor', config, env);
+  const ghBin = resolveBin('gh', config, env);
+  if (!r2eBin || !harborBin) {
+    const missing = [!r2eBin && 'repo2rlenv', !harborBin && 'harbor'].filter(Boolean).join(', ');
+    throw new PipelineError(`faltan binarios: ${missing} — corre \`dream-cycle doctor\` para el diagnóstico completo`, 1);
+  }
+
+  log(`== dream-cycle v0 :: ${repo} (limit=${limit} since=${since}) ==`);
+
+  // 1. SINTETIZAR (idempotente: salta si el corpus ya existe con tareas)
+  const hasTasks = subdirs(corpus).some((d) => existsSync(join(corpus, d, 'task.toml')));
+  if (existsSync(corpus) && hasTasks) {
+    log(`-- corpus existente: ${corpus} (saltando generate)`);
+  } else {
+    log(`-- generate pr_diff → ${corpus}`);
+    const gen = spawnSync(r2eBin, [
+      'generate', '--repo', repo, '--pipeline', 'pr_diff', '--out', corpus,
+      '--pipeline-opt', `limit=${limit}`, '--pipeline-opt', `since=${since}`,
+    ], { stdio: 'inherit', env: childEnv });
+    if (gen.status !== 0) throw new PipelineError('repo2rlenv generate falló', 1);
+  }
+  const nTasks = subdirs(corpus).length;
+  if (nTasks < minTasks) {
+    throw new PipelineError(`corpus insuficiente (${nTasks} tareas) — repo sin PRs minables post-${since}`, 3);
+  }
+  const val = spawnSync(r2eBin, ['validate', corpus], { stdio: ['ignore', 'ignore', 'inherit'], env: childEnv });
+  if (val.status !== 0) throw new PipelineError('repo2rlenv validate falló', 1);
+  log(`-- validate OK (${nTasks} tareas)`);
+
+  // 1b. ENDURECER Dockerfiles para repos privados (hallazgo upstream 2026-06-11)
+  hardenDockerfiles(corpus, log);
+
+  // 2. CALIBRAR (idempotente: salta si el job ya existe)
+  // Repos privados: el Dockerfile emitido clona con ARG GITHUB_TOKEN — se lo
+  // alimentamos vía overlay de compose + token de gh. El token JAMÁS toca disco:
+  // el overlay solo lleva el placeholder ${GITHUB_TOKEN} y compose interpola
+  // desde el entorno. Nota: un build-arg queda visible en docker history de la
+  // imagen local; aceptable para runs locales, no publicar esas imágenes.
+  const harborExtra = [];
+  let overlayTmp = null;
+  try {
+    if (ghBin) {
+      const tok = spawnSync(ghBin, ['auth', 'token'], { encoding: 'utf-8', env: childEnv });
+      if (tok.status === 0 && tok.stdout && tok.stdout.trim()) {
+        childEnv.GITHUB_TOKEN = tok.stdout.trim();
+        overlayTmp = mkdtempSync(join(tmpdir(), 'dream-cycle-'));
+        const overlayPath = join(overlayTmp, 'overlay.yaml');
+        writeFileSync(overlayPath, 'services:\n  main:\n    build:\n      args:\n        GITHUB_TOKEN: ${GITHUB_TOKEN}\n');
+        harborExtra.push('--extra-docker-compose', overlayPath);
+      }
+    }
+    for (const agent of ['oracle', 'nop']) {
+      const jobDir = agent === 'oracle' ? oracleJob : nopJob;
+      if (existsSync(jobDir)) {
+        log(`-- job ${agent} existente (saltando)`);
+        continue;
+      }
+      log(`-- harbor run -a ${agent} ...`);
+      spawnSync(harborBin, ['run', '-p', corpus, '-a', agent, '--env', 'docker', '-o', jobDir, ...harborExtra],
+        { stdio: 'ignore', env: childEnv });
+      // exit code IGNORADO (el `|| true` del bash): los trials pueden figurar
+      // 'failed' por la incompat pydantic conocida; los artefactos del verifier
+      // son la fuente de verdad (memoria harbor-repo2rlenv-schema-incompat)
+    }
+  } finally {
+    if (overlayTmp) rmSync(overlayTmp, { recursive: true, force: true });
+  }
+
+  // 3. CURAR: tareas sin reward o con oracle < umbral → exclusiones DECLARADAS
+  let exclusions = [];
+  try {
+    const s = runGate({
+      jobs: [oracleJob], corpora: [corpus], mode: 'oracle', exclude: [],
+      noWrite: true, quiet: true, env: childEnv,
+    });
+    exclusions = [
+      ...s.perTask.filter((p) => p.reward < defaults.oracleThreshold).map((p) => p.task),
+      ...s.tasksMissing,
+    ];
+  } catch {
+    exclusions = []; // gate de curación ilegible → sin exclusiones (el gate final decidirá)
+  }
+  log(`-- curación: ${exclusions.length} tareas inevaluables declaradas`);
+  const nEval = nTasks - exclusions.length;
+  if (nEval < minTasks) throw new PipelineError(`tras curar quedan ${nEval} tareas — corpus no útil`, 3);
+
+  // 4. GATE: oracle debe PASAR (este run SÍ escribe result.json al runsDir), nop debe FALLAR
+  log('-- gate oracle (esperado: PASS)');
+  const oracleSummary = runGate({
+    jobs: [oracleJob], corpora: [corpus], mode: 'oracle', exclude: exclusions,
+    runsDir, env: childEnv,
+  });
+  if (!oracleSummary.gate.allPass) throw new PipelineError('gate oracle FALLÓ tras curación — investigar', 4);
+
+  log('-- gate nop (esperado: FAIL — el corpus discrimina)');
+  let nopPassed = false;
+  try {
+    const nop = runGate({
+      jobs: [nopJob], corpora: [corpus], mode: 'oracle', exclude: exclusions,
+      noWrite: true, quiet: true, env: childEnv,
+    });
+    nopPassed = nop.gate.allPass === true;
+  } catch {
+    nopPassed = false; // error del gate nop = "no pasó" = falsificación OK
+  }
+  if (nopPassed) throw new PipelineError('el gate PASÓ con el agente nulo — el corpus NO discrimina', 5);
+  log('-- falsificación OK');
+
+  // 5. RADAR (gap = señal para el humano, NO error: no propaga al exit code)
+  log('-- radar');
+  const { report } = radarReport({
+    runsDir, benchmark: defaults.benchmark, epsilon: defaults.epsilon, target: defaults.target,
+  });
+  log(`# dream-cycle radar | ${report.seriesAnalyzed} series, ${report.runsAnalyzed} runs`);
+  if (!report.gaps.length) log('  sin gaps — todo dentro de baseline');
+  for (const g of report.gaps) log(`  [${g.type}] ${g.issueDraft}`);
+  mkdirSync(runsDir, { recursive: true });
+  writeFileSync(join(runsDir, 'dream-cycle-radar-latest.json'), JSON.stringify(report, null, 2));
+
+  log(`== dream-cycle v0 completo para ${repo} ==`);
+  log(`   corpus: ${corpus} (${nEval} evaluables) · gate: ${join(runsDir, 'repo2rlenv-capability-latest.json')}`);
+  log(`   brazo agente (opcional, suscripción): harbor run -p ${corpus} -a claude-code -m <model> \\`);
+  log(`     --ae CLAUDE_CODE_OAUTH_TOKEN=<token> --ae CLAUDE_FORCE_OAUTH=1 --env docker -o ${join(jobsDir, `dc-${slug}-agent`)}`);
+}
+
+export async function runCli({ argv, cwd, env }) {
+  let repo = null, limit = null, since = null;
+  for (let i = 0; i < argv.length; i++) {
+    const k = argv[i];
+    if (k === '--limit') { limit = Number(argv[++i]); }
+    else if (k === '--since') { since = argv[++i]; }
+    else if (k.startsWith('--')) throw new UsageError(`run: argumento desconocido ${k}`);
+    else if (repo === null) repo = k;
+    else throw new UsageError(`run: argumento inesperado ${k}`);
+  }
+  if (!repo || !/^[^\/\s]+\/[^\/\s]+$/.test(repo)) {
+    throw new UsageError('uso: dream-cycle run <owner/repo> [--limit N] [--since YYYY-MM-DD]');
+  }
+
+  try {
+    await runPipeline({ repo, limit, since, cwd, env });
+    return 0;
+  } catch (e) {
+    if (e instanceof PipelineError) {
+      console.error(`!! ${e.message}`);
+      return e.code;
+    }
+    throw e;
+  }
+}

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "dream-cycle",
+  "version": "0.1.0",
+  "description": "Dream Cycle v0: synthesize a post-cutoff eval corpus from any GitHub repo (repo2rlenv pr_diff), calibrate with oracle/nop agents via harbor, gate with falsification, and run a reactive capability radar. The radar proposes; the human decides.",
+  "type": "module",
+  "license": "MIT",
+  "bin": { "dream-cycle": "bin/dream-cycle.mjs" },
+  "files": ["bin", "lib", "README.md"],
+  "engines": { "node": ">=20" },
+  "scripts": { "test": "node --test tests/*.test.mjs", "prepublishOnly": "npm test" },
+  "repository": { "type": "git", "url": "git+https://github.com/DarkCodePE/investigador.git", "directory": "packages/dream-cycle" },
+  "keywords": ["eval", "benchmark", "rl-environment", "harbor", "repo2rlenv", "capability-gate", "agent-evaluation"],
+  "publishConfig": { "access": "public", "tag": "latest" }
+}