@trycore/spec-build-harness 0.8.5 → 0.11.0

package/dist/cli.js

@@ -7,6 +7,7 @@ import { update } from './commands/update.js';
 import { status } from './commands/status.js';
 import { uninstall } from './commands/uninstall.js';
 import { doctor } from './commands/doctor.js';
+import { migrate } from './commands/migrate.js';
 const program = new Command();
 program
     .name('trycore-build')
@@ -24,6 +25,9 @@ program
     .option('--runtime <semver>', 'Semver del runtime (ej. ">=18.18")')
     .option('--prd-path <path>', 'Ruta#ancla del PRD técnico (fuente del allowlist)')
     .option('--yes', 'No interactivo: usa defaults para el stack')
+    .option('--runtime-url <url>', 'URL del Agent Orchestrator Runtime (con --runtime-token, registra el agente)')
+    .option('--runtime-token <token>', 'Token de proyecto emitido por un ADMIN en el hub')
+    .option('--runtime-mode <mode>', 'legacy|dual|runtime tras registrar (default: dual)')
     .action(async (directory, opts) => {
     try {
         await init({
@@ -38,6 +42,9 @@ program
                 prdPath: opts.prdPath,
                 yes: Boolean(opts.yes),
             },
+            runtimeUrl: opts.runtimeUrl,
+            runtimeToken: opts.runtimeToken,
+            runtimeMode: opts.runtimeMode,
         });
     }
     catch (err) {
@@ -99,6 +106,31 @@ program
         process.exit(1);
     }
 });
+program
+    .command('migrate')
+    .description('Prepara el bundle de estado (history/releases/hechos) de build-state.json para que un ADMIN lo importe en el hub. Nunca sube nada.')
+    .argument('[directory]', 'Directorio del proyecto', '.')
+    .option('--out <path>', 'Ruta de salida del bundle (default: .claude/state/migration-bundle.json)')
+    .option('--project-ref <ref>', 'Identificador de proyecto en el hub (default: nombre del directorio)')
+    .option('--graph <path>', 'Bundle de grafo (graph-bundle.py) a embeber como sección graph (default: .claude/state/graph-bundle.json si existe)')
+    .option('--pre-harness <path>', 'Fichero JSON con las épicas construidas ANTES de instalar el arnés, confirmadas por el humano: {"epics": [{"code": "EP-001", "note": "…"}]} — se importan archivadas sin declarar gates, con acta de migración')
+    .option('--verify', 'Solo verifica el bundle normalizado contra los invariantes del hub (offline, no escribe nada); exit ≠0 si hay violaciones')
+    .action(async (directory, opts) => {
+    try {
+        await migrate({
+            targetDir: directory,
+            outFile: opts.out,
+            projectRef: opts.projectRef,
+            graphFile: opts.graph,
+            preHarnessFile: opts.preHarness,
+            verifyOnly: Boolean(opts.verify),
+        });
+    }
+    catch (err) {
+        console.error('✗ Error:', err.message);
+        process.exit(1);
+    }
+});
 program.parseAsync(process.argv).catch((err) => {
     console.error('✗ Error inesperado:', err);
     process.exit(1);

package/dist/commands/doctor.js

@@ -8,6 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { targetPaths } from '../lib/paths.js';
+import { runtimeMode, readCredentials, getAgentContext, readLock, outboxStats } from '../lib/runtime-client.js';
 export function hasBinary(bin) {
     if (process.platform === 'win32') {
         return spawnSync('where', [bin], { stdio: 'ignore' }).status === 0;
@@ -87,6 +88,47 @@ export async function doctor(opts) {
     else {
         console.log('Scaffold (Paso 1): — (sin build-state.json; corre `trycore-build init`)');
     }
+    // Runtime [EP-OR-08-D]: conectividad, validez del token, frescura del lock, cola offline.
+    const mode = runtimeMode(targetDir);
+    console.log('');
+    console.log(`Runtime (modo ${mode}):`);
+    if (mode === 'legacy') {
+        console.log('  — legacy: sin conexión al runtime (corre `trycore-build init --runtime-url … --runtime-token …`)');
+    }
+    else {
+        const creds = readCredentials(targetDir);
+        console.log(`  Token:      ${creds.project_token ? '✓ presente' : '✗ falta — corre init con --runtime-token'}`);
+        if (creds.project_token) {
+            const ctx = await getAgentContext(targetDir);
+            if (ctx.status === 200) {
+                console.log('  Conexión:   ✓ el runtime responde');
+            }
+            else if (ctx.status === 401 || ctx.status === 403) {
+                console.log('  Conexión:   ✗ token inválido/revocado — pide uno nuevo al ADMIN');
+            }
+            else if (ctx.status === 0) {
+                console.log('  Conexión:   ⚠ runtime inalcanzable — se trabaja offline con el último lock');
+            }
+            else {
+                console.log(`  Conexión:   ⚠ el runtime respondió ${ctx.status}`);
+            }
+        }
+        const lock = readLock(targetDir);
+        if (lock.manifestHash) {
+            console.log(`  Contexto:   ✓ sincronizado (${lock.fileCount} archivo(s), ${lock.syncedAt ?? 'fecha desconocida'})`);
+        }
+        else {
+            console.log('  Contexto:   ⚠ sin sincronizar aún (se resuelve en la primera sesión Claude)');
+        }
+        const ob = outboxStats(targetDir);
+        if (ob.count > 0) {
+            const ageMin = ob.oldestAgeSeconds !== null ? Math.floor(ob.oldestAgeSeconds / 60) : null;
+            console.log(`  Cola:       ${ob.count} evento(s) pendiente(s) (${(ob.totalBytes / 1024).toFixed(0)} KB${ageMin !== null ? `, el más viejo hace ${ageMin} min` : ''}) — el daemon los despacha`);
+        }
+        else {
+            console.log('  Cola:       vacía');
+        }
+    }
     // Detección de doble canal (CLI settings.json + plugin) [H3]
     const settingsHasHooks = fs.existsSync(t.settingsFile) &&
         /hooks\/build\//.test(fs.readFileSync(t.settingsFile, 'utf8'));

package/dist/commands/init.js

@@ -6,12 +6,14 @@
 // hace el slash command /build:onboard (Claude), NO este binario.
 import fs from 'node:fs';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { ASSETS, readPackageVersion, targetPaths } from '../lib/paths.js';
 import { linkChildren, countChildren, chmodExec } from '../lib/install-engine.js';
 import { upsertMarkedBlock } from '../lib/markers.js';
 import { seedState, seedConfig, seedBuildConfig, stampProjectKind } from '../lib/state-seed.js';
 import { mergeHarnessSettings } from '../lib/settings-merge.js';
 import { captureStack, renderAllowlist } from '../lib/stack-prompt.js';
+import { registerAgent, isPlausibleUrl } from '../lib/runtime-client.js';
 import { checkDeps } from './doctor.js';
 const BEGIN = '<!-- BEGIN trycore-build-harness ';
 const END = '<!-- END trycore-build-harness -->';
@@ -55,6 +57,11 @@ export async function init(opts) {
         chmodExec(t.hooksBuild); // preserva +x [H1] (recorre hooks/build/ incl. lib/)
         chmodExec(t.scriptsLib);
     }
+    // asset-types.json: versionado como schema/README, se refresca en cada init/update.
+    // session-start.sh lo busca en .claude/asset-types.json (protocolo §6; ver su comentario
+    // "la siembra es del sub-slice D").
+    if (fs.existsSync(ASSETS.assetTypes))
+        fs.copyFileSync(ASSETS.assetTypes, t.assetTypesFile);
     // 2) Estado (schema/README versionados; build-state.json vacío solo si falta) [C1]
     const { stateSeeded } = seedState(targetDir);
     const projectKind = stampProjectKind(targetDir);
@@ -75,6 +82,11 @@ export async function init(opts) {
     syncClaudeMdBlock(targetDir, version);
     // 6) .gitignore: lista los assets symlinkeados + estado vivo [H1]
     syncGitignoreBlock(targetDir, linkMode);
+    // 6-bis) Runtime (opcional, [EP-OR-08-D]): con --runtime-url/--runtime-token, registra el
+    // agente (bootstrap, fuera de una sesión Claude) y dispara el primer sync de contexto.
+    // Fail-open: un runtime inalcanzable en init NUNCA aborta la instalación — degrada a
+    // legacy y el registro/sync se reintentan en la primera sesión (session-start.sh).
+    const runtime = await maybeRegisterRuntime(targetDir, t, version, opts);
     // 7) marca de versión
     fs.writeFileSync(t.versionFile, version + '\n', 'utf8');
     // 8) Resumen
@@ -89,10 +101,71 @@ export async function init(opts) {
     console.log(`  Config:    ${configSeeded ? 'stack-allowlist.json sembrado' : 'stack-allowlist.json preservado'}`);
     console.log(`  Config:    ${buildConfigSeeded ? 'build-config.json sembrado' : 'build-config.json preservado'}`);
     console.log(`  Proyecto:  ${projectKind === 'brownfield' ? 'brownfield (épica caparazón N/A)' : projectKind === 'greenfield' ? 'greenfield (épica caparazón requerida — se define en /build:onboard)' : 'indeterminado (se confirma en /build:onboard)'}`);
+    console.log(`  Runtime:   ${runtime}`);
     console.log('');
     console.log('Siguiente paso — abre Claude Code y ejecuta:');
     console.log('  /build:onboard   # parametriza el dominio (PII, capa IA, capa determinista) y escribe memoria');
 }
+/**
+ * Registro del agente CLI + primer sync de contexto, solo si el llamador pasó
+ * --runtime-url/--runtime-token. Fail-open en TODO: nunca lanza, nunca aborta init.
+ * Devuelve una línea de una sola frase para el resumen.
+ */
+async function maybeRegisterRuntime(targetDir, t, version, opts) {
+    if (!opts.runtimeUrl && !opts.runtimeToken) {
+        return 'legacy (sin --runtime-url/--runtime-token; corre `trycore-build init --runtime-url … --runtime-token …` cuando el ADMIN te dé el token)';
+    }
+    if (!opts.runtimeUrl || !opts.runtimeToken) {
+        console.log('  ⚠ runtime: --runtime-url y --runtime-token deben darse juntos — se omite el registro (modo legacy).');
+        return 'legacy (faltó --runtime-url o --runtime-token)';
+    }
+    if (!isPlausibleUrl(opts.runtimeUrl)) {
+        console.log(`  ⚠ runtime: --runtime-url "${opts.runtimeUrl}" no es una URL http(s) válida — se omite el registro (modo legacy).`);
+        return 'legacy (--runtime-url inválida)';
+    }
+    const mode = opts.runtimeMode ?? 'dual';
+    let assetTypes = [];
+    if (fs.existsSync(t.assetTypesFile)) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(t.assetTypesFile, 'utf8'));
+            assetTypes = Array.isArray(parsed?.types) ? parsed.types : [];
+        }
+        catch {
+            /* asset-types.json ilegible: se registra con [] — no bloquea */
+        }
+    }
+    const res = await registerAgent(targetDir, { url: opts.runtimeUrl, token: opts.runtimeToken, harnessVersion: version, assetTypes });
+    if (!res.ok) {
+        console.log(`  ⚠ runtime: no se pudo registrar (${res.message ?? 'error desconocido'}). Credenciales guardadas; se reintenta en la primera sesión.`);
+        return `legacy (registro falló: ${res.message ?? 'error desconocido'})`;
+    }
+    // build-config.json ya está sembrado (paso 3) — escribe runtime.mode sin pisar el resto.
+    try {
+        const cfg = JSON.parse(fs.readFileSync(t.buildConfigFile, 'utf8'));
+        cfg.runtime = { ...(cfg.runtime ?? {}), mode };
+        fs.writeFileSync(t.buildConfigFile, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+    }
+    catch {
+        console.log('  ⚠ runtime: no se pudo escribir runtime.mode en build-config.json (queda legacy hasta ajustarlo a mano).');
+        return 'legacy (no se pudo escribir build-config.json)';
+    }
+    console.log(`  ✓ runtime: agente registrado (modo ${mode}).`);
+    // Primer sync de contexto: se delega al script bash ya instalado (mismo protocolo que
+    // usa toda sesión Claude) en vez de reimplementar el algoritmo de sync en TS.
+    const syncScript = path.join(t.hooksBuild, 'context-sync.sh');
+    if (fs.existsSync(syncScript)) {
+        const r = spawnSync('bash', [syncScript], { cwd: targetDir, env: { ...process.env, CLAUDE_PROJECT_DIR: targetDir }, encoding: 'utf8' });
+        if (r.status === 0) {
+            console.log('  ✓ runtime: primer sync de contexto completado.');
+            if (r.stdout?.trim())
+                console.log(r.stdout.trim().split('\n').map((l) => `    ${l}`).join('\n'));
+        }
+        else {
+            console.log('  ⚠ runtime: el primer sync de contexto no terminó limpio — se reintenta en la primera sesión.');
+        }
+    }
+    return `${mode} (agente registrado, primer sync intentado)`;
+}
 function syncClaudeMdBlock(targetDir, version) {
     const t = targetPaths(targetDir);
     if (!fs.existsSync(ASSETS.templateClaudeMd)) {
@@ -142,7 +215,17 @@ function syncGitignoreBlock(targetDir, mode) {
     const isGitRepo = fs.existsSync(path.join(targetDir, '.git'));
     if (!isGitRepo && !fs.existsSync(t.gitignore))
         return;
-    const lines = [GI_BEGIN + ' ───────────────────────', '.claude/state/build-state.json'];
+    const lines = [
+        GI_BEGIN + ' ───────────────────────',
+        '.claude/state/build-state.json',
+        // Credenciales del runtime (token 0600) y sus artefactos derivados [EP-OR-08-D]:
+        // nunca deben poder llegar a un `git add` descuidado, sin importar el modo de link.
+        '.claude/state/runtime.credentials',
+        '.claude/state/context.lock',
+        '.claude/state/runtime-projection.json',
+        '.claude/state/.runtime-http-status',
+        '.claude/state/outbox/',
+    ];
     if (mode === 'symlink') {
         // Los symlinks absolutos a node_modules global se rompen en otra máquina si se commitean.
         lines.push('.claude/agents/build/', '.claude/commands/opsx/', '.claude/commands/build/', '.claude/hooks/build/', '.claude/scripts/lib/');

package/dist/commands/migrate.js

@@ -0,0 +1,153 @@
+// commands/migrate.ts — prepara el bundle normalizado del build-state.json legacy para que
+// un ADMIN lo importe en la consola del hub (docs/superpowers/specs/2026-08-20-cliente-migrate-normalizacion-eventos-design.md).
+// Nunca sube nada: el import es acto de gobierno, igual que el bundle de grafo (Task 13, C).
+import fs from 'node:fs';
+import path from 'node:path';
+import { targetPaths } from '../lib/paths.js';
+import { buildStateBundle, extractGraphSection, graphEpicsWithoutRepresentation, verifyStateBundle, } from '../lib/state-bundle.js';
+import { parsePreHarnessList } from '../lib/normalize.js';
+export async function migrate(opts) {
+    const targetDir = path.resolve(opts.targetDir);
+    const t = targetPaths(targetDir);
+    if (!fs.existsSync(t.stateFile)) {
+        console.error(`✗ No hay build-state.json en ${t.stateFile} — nada que migrar.`);
+        process.exit(1);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(t.stateFile, 'utf8'));
+    }
+    catch (err) {
+        console.error(`✗ build-state.json no parsea como JSON: ${err.message}`);
+        process.exit(1);
+    }
+    // Épicas pre-arnés (issue #42): construidas ANTES de instalar el arnés, sin
+    // entrada en history[] — importadas sin esto quedan «sin empezar» en el hub
+    // y claim_next las reparte como trabajo nuevo (incidente del primer piloto).
+    // La lista la escribe/confirma el humano; nunca se infiere del grafo.
+    let preHarness;
+    if (opts.preHarnessFile) {
+        const preHarnessFile = path.resolve(opts.preHarnessFile);
+        if (!fs.existsSync(preHarnessFile)) {
+            console.error(`✗ No existe el fichero pre-arnés: ${preHarnessFile}`);
+            process.exit(1);
+        }
+        let preHarnessRaw;
+        try {
+            preHarnessRaw = JSON.parse(fs.readFileSync(preHarnessFile, 'utf8'));
+        }
+        catch (err) {
+            console.error(`✗ El fichero pre-arnés no parsea como JSON: ${err.message}`);
+            process.exit(1);
+        }
+        const { list, errors } = parsePreHarnessList(preHarnessRaw);
+        if (list === null || errors.length > 0) {
+            console.error(`✗ El fichero pre-arnés (${preHarnessFile}) no es válido:`);
+            for (const e of errors)
+                console.error(`    ✗ ${e}`);
+            console.error('  Forma esperada: {"epics": [{"code": "EP-001", "note": "…opcional…"}], "as_of": "…ISO opcional…"}');
+            process.exit(1);
+        }
+        preHarness = list;
+    }
+    const projectRef = opts.projectRef ?? path.basename(targetDir);
+    const bundle = buildStateBundle(raw, projectRef, preHarness);
+    // Sección `graph` embebida (issue #41): el import del hub la consume DENTRO del
+    // bundle de estado (ImportBundleIn.graph) — un fichero de grafo aparte se ignora
+    // y la historia falla («la épica no existe en el grafo»). El grafo se genera con
+    // scripts/lib/graph-bundle.py (flujo de /build:onboard); aquí solo se embebe.
+    const defaultGraphFile = path.join(t.stateDir, 'graph-bundle.json');
+    const graphFile = opts.graphFile
+        ? path.resolve(opts.graphFile)
+        : fs.existsSync(defaultGraphFile)
+            ? defaultGraphFile
+            : undefined;
+    if (graphFile) {
+        if (!fs.existsSync(graphFile)) {
+            console.error(`✗ No existe el bundle de grafo: ${graphFile}`);
+            process.exit(1);
+        }
+        let graphRaw;
+        try {
+            graphRaw = JSON.parse(fs.readFileSync(graphFile, 'utf8'));
+        }
+        catch (err) {
+            console.error(`✗ El bundle de grafo no parsea como JSON: ${err.message}`);
+            process.exit(1);
+        }
+        const { graph, errors } = extractGraphSection(graphRaw);
+        if (graph === null) {
+            console.error(`✗ El bundle de grafo (${graphFile}) no está en el formato del hub — no se escribe el fichero.`);
+            for (const e of errors)
+                console.error(`    ✗ ${e}`);
+            console.error('  Regenéralo con scripts/lib/graph-bundle.py (layer FOUNDATIONAL|BUSINESS, historias con `code`, `release_line` por épica).');
+            process.exit(1);
+        }
+        bundle.graph = graph;
+        // Síntoma exacto del incidente del piloto: épicas del grafo sin slice en
+        // history[] ni declaración pre-arnés quedan «sin empezar» en el hub y
+        // claim_next las reparte como trabajo nuevo. SOLO aviso — la lista
+        // pre-arnés la confirma el humano, nada se auto-añade.
+        const unrepresented = graphEpicsWithoutRepresentation(graph, bundle.history.map((h) => h.epic_code));
+        if (unrepresented.length > 0) {
+            bundle.warnings.push(`graph: ${unrepresented.length} épica(s) del grafo sin slice en el historial ni declaración pre-arnés (${unrepresented.join(', ')}) — quedarán «sin empezar» en el hub y claim_next las repartirá como trabajo nuevo; si ya están construidas, decláralas en el fichero de --pre-harness (nunca se auto-añaden)`);
+        }
+    }
+    if (bundle.validation_errors.length > 0) {
+        console.error('✗ El bundle normalizado no pasa la validación local — no se escribe el fichero.');
+        for (const e of bundle.validation_errors)
+            console.error(`    ✗ ${e}`);
+        process.exit(1);
+    }
+    // Verificación offline contra los invariantes del hub (issue #40): la misma
+    // entrada que el import rechazaría debe salir aquí, no en la consola del ADMIN.
+    const violations = verifyStateBundle(bundle);
+    if (opts.verifyOnly) {
+        if (violations.length === 0) {
+            console.log('✓ Verificación offline: el bundle normalizado no viola ningún invariante conocido del hub.');
+            console.log('  (No se escribió ningún fichero: --verify solo verifica.)');
+            return;
+        }
+        console.error(`✗ Verificación offline: ${violations.length} violación(es) de los invariantes del hub:`);
+        for (const v of violations)
+            console.error(`    ✗ ${v.source_key}: ${v.message}`);
+        process.exit(1);
+    }
+    if (violations.length > 0) {
+        // El destino del bundle es un ADMIN: un bundle que el hub rechazaría no se
+        // entrega en silencio — se aborta sin escribir, igual que la validación local.
+        console.error(`✗ El bundle viola ${violations.length} invariante(s) del hub — no se escribe el fichero.`);
+        for (const v of violations)
+            console.error(`    ✗ ${v.source_key}: ${v.message}`);
+        console.error('  Corrige el build-state.json de origen (o reporta el caso al arnés) y reintenta.');
+        process.exit(1);
+    }
+    bundle.generated_at = new Date().toISOString();
+    const outFile = opts.outFile ? path.resolve(opts.outFile) : path.join(t.stateDir, 'migration-bundle.json');
+    fs.mkdirSync(path.dirname(outFile), { recursive: true });
+    fs.writeFileSync(outFile, JSON.stringify(bundle, null, 2) + '\n', 'utf8');
+    console.log(`✓ Bundle de estado preparado: ${outFile}`);
+    console.log(`  ${bundle.history.length} slice(s) de historial · ${bundle.releases.length} release(s) · ` +
+        `${bundle.fronts.length} front(s) · ${bundle.facts.length} hecho(s) de proyecto · ${bundle.unmapped.length} entrada(s) no mapeable(s)`);
+    if (preHarness) {
+        console.log(`  Épicas pre-arnés declaradas: ${preHarness.epics.length} (${preHarness.epics.map((e) => e.code).join(', ')}) — archivadas sin declarar gates, con acta de migración`);
+    }
+    if (bundle.graph) {
+        console.log(`  Grafo embebido: ${bundle.graph.epics.length} épica(s) (sección graph del bundle — un solo fichero para el ADMIN)`);
+    }
+    else {
+        console.log('  ⚠ Grafo: NO incluido — el hub reportará «Grafo: no incluida» y rechazará la historia si el');
+        console.log('    grafo no fue importado antes. Genera el grafo con scripts/lib/graph-bundle.py y pásalo');
+        console.log('    con --graph <fichero> (o déjalo en .claude/state/graph-bundle.json).');
+    }
+    if (bundle.warnings.length > 0) {
+        console.log('');
+        console.log('  Avisos (no bloquean; corrígelos en discovery si aplica):');
+        for (const w of bundle.warnings)
+            console.log(`    ⚠ ${w}`);
+    }
+    console.log('');
+    console.log('Este fichero NO se sube automáticamente: es un acto de gobierno. Entrégalo a un');
+    console.log('ADMIN con esta instrucción literal: «súbelo en la consola del hub, pantalla de');
+    console.log('import histórico del proyecto». El import es idempotente y reanuda si falló a medias.');
+}

package/dist/commands/status.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { readPackageVersion, targetPaths, PACKAGE_ROOT } from '../lib/paths.js';
 import { countChildren } from '../lib/install-engine.js';
 import { hasBinary } from './doctor.js';
+import { runtimeMode, getAgentContext, readProjection, readLock } from '../lib/runtime-client.js';
 export async function status(opts) {
     const targetDir = path.resolve(opts.targetDir);
     const t = targetPaths(targetDir);
@@ -32,6 +33,39 @@ export async function status(opts) {
     console.log('Requisitos externos:');
     console.log(`  openspec:   ${hasBinary('openspec') ? '✓' : '✗ falta (npm i -g @fission-ai/openspec)'}`);
     console.log(`  python3:    ${hasBinary('python3') ? '✓' : '✗ falta'}`);
+    // Runtime [EP-OR-08-D]: en dual/runtime, la fuente preferida es la caché de proyección
+    // (la normaliza agent-context.sh — esta CLI no duplica esa lógica, solo lee y pinguea).
+    const mode = runtimeMode(targetDir);
+    if (mode !== 'legacy') {
+        console.log('');
+        console.log(`Runtime (modo ${mode}):`);
+        const ctx = await getAgentContext(targetDir);
+        console.log(`  Conexión:     ${ctx.status === 200 ? '✓' : ctx.status === 0 ? '⚠ inalcanzable (trabajando offline)' : `⚠ respondió ${ctx.status}`}`);
+        const proj = readProjection(targetDir);
+        if (proj.fetched_at) {
+            const ageS = Math.max(0, Math.floor((Date.now() - Date.parse(String(proj.fetched_at))) / 1000));
+            console.log(`  Proyección:   ✓ v${proj.context?.version ?? '?'} (hace ${ageS}s${ageS > 900 ? ' — ⚠ stale' : ''})`);
+            const slice = proj.active_slice;
+            if (slice) {
+                console.log(`  Slice activo: ${slice.epic_code ?? '?'} (fase ${slice.phase ?? '?'})`);
+            }
+            else {
+                console.log('  Slice activo: ninguno');
+            }
+            const nudges = Array.isArray(proj.nudges) ? proj.nudges : [];
+            if (nudges.length > 0)
+                console.log(`  Nudges:       ${nudges.length} pendiente(s)`);
+        }
+        else {
+            console.log('  Proyección:   — sin caché aún (se resuelve en la primera sesión Claude)');
+        }
+        const lock = readLock(targetDir);
+        console.log(`  Contexto:     ${lock.manifestHash ? `✓ sincronizado (${lock.fileCount} archivo(s))` : '⚠ sin sincronizar'}`);
+        if (mode === 'runtime') {
+            console.log('══════════════════════════════════════════════════════');
+            return;
+        }
+    }
     // Estado del arnés
     if (fs.existsSync(t.stateFile)) {
         try {