@trycore/spec-build-harness 0.1.0

package/dist/commands/status.js

@@ -0,0 +1,59 @@
+// commands/status.ts — estado de instalación + fase del arnés.
+import fs from 'node:fs';
+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';
+export async function status(opts) {
+    const targetDir = path.resolve(opts.targetDir);
+    const t = targetPaths(targetDir);
+    const pkgVersion = readPackageVersion();
+    console.log('════════ Trycore spec-build-harness — estado ════════');
+    console.log(`Proyecto:     ${targetDir}`);
+    console.log(`Paquete CLI:  v${pkgVersion}  (${PACKAGE_ROOT})`);
+    if (fs.existsSync(t.versionFile)) {
+        const installed = fs.readFileSync(t.versionFile, 'utf8').trim();
+        const drift = installed === pkgVersion ? '' : '  ⚠ desincronizado — corre `trycore-build update`';
+        console.log(`Instalado:    v${installed}${drift}`);
+    }
+    else {
+        console.log('Instalado:    — (corre `trycore-build init`)');
+        console.log('══════════════════════════════════════════════════════');
+        return;
+    }
+    console.log('');
+    console.log('Componentes:');
+    console.log(`  Agentes:    ${countChildren(t.agentsBuild)} en .claude/agents/build/`);
+    console.log(`  Comandos:   ${countChildren(t.commandsOpsx)} /opsx:* · ${countChildren(t.commandsBuild)} /build:*`);
+    console.log(`  Skills:     ${countChildren(t.skillsDir)} en .claude/skills/`);
+    console.log(`  Hooks:      ${countChildren(t.hooksBuild)} en .claude/hooks/build/`);
+    console.log('');
+    console.log('Requisitos externos:');
+    console.log(`  openspec:   ${hasBinary('openspec') ? '✓' : '✗ falta (npm i -g @fission-ai/openspec)'}`);
+    console.log(`  python3:    ${hasBinary('python3') ? '✓' : '✗ falta'}`);
+    // Estado del arnés
+    if (fs.existsSync(t.stateFile)) {
+        try {
+            const st = JSON.parse(fs.readFileSync(t.stateFile, 'utf8'));
+            console.log('');
+            console.log('Estado del arnés:');
+            console.log(`  Fase:       ${st.harness_phase ?? '?'}`);
+            const slice = st.active_slice;
+            if (slice) {
+                const openGates = Object.entries(slice.gates ?? {})
+                    .filter(([, v]) => v === false || v === null)
+                    .map(([k]) => k);
+                console.log(`  Slice activo: ${slice.epica ?? '?'} (fase ${slice.phase ?? '?'})`);
+                console.log(`  Gates abiertos: ${openGates.length ? openGates.join(', ') : 'ninguno'}`);
+            }
+            else {
+                console.log('  Slice activo: ninguno');
+            }
+            console.log(`  Historial:  ${(st.history ?? []).length} slice(s) · Releases: ${(st.releases ?? []).length}`);
+        }
+        catch {
+            console.log('  ⚠ build-state.json malformado');
+        }
+    }
+    console.log('══════════════════════════════════════════════════════');
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,52 @@
+// commands/uninstall.ts — quita SOLO lo que init puso. Preserva state/ y config/
+// (estado vivo y allowlist son del consumidor), igual que la referencia preserva docs/.
+import fs from 'node:fs';
+import path from 'node:path';
+import { ASSETS, targetPaths } from '../lib/paths.js';
+import { removeMarkedBlock } from '../lib/markers.js';
+import { removeHarnessSettings } from '../lib/settings-merge.js';
+export async function uninstall(opts) {
+    const targetDir = path.resolve(opts.targetDir);
+    const t = targetPaths(targetDir);
+    if (!fs.existsSync(t.versionFile)) {
+        console.error(`⚠  No se detecta instalación de trycore-build-harness en ${targetDir}`);
+        process.exit(1);
+    }
+    console.log(`▶ uninstall trycore-build-harness de ${targetDir}`);
+    // 1) Assets exclusivos del arnés
+    for (const p of [t.agentsBuild, t.commandsOpsx, t.commandsBuild, t.hooksBuild]) {
+        if (fs.existsSync(p))
+            fs.rmSync(p, { recursive: true, force: true });
+    }
+    // Skills del arnés (NO toda la carpeta skills/, que es compartida con spec-product-flow)
+    const skillNames = fs.existsSync(ASSETS.skills)
+        ? fs.readdirSync(ASSETS.skills, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name)
+        : [];
+    for (const s of skillNames) {
+        const p = path.join(t.skillsDir, s);
+        if (fs.existsSync(p) || isSymlink(p))
+            fs.rmSync(p, { recursive: true, force: true });
+    }
+    // 2) Marca de versión
+    if (fs.existsSync(t.versionFile))
+        fs.rmSync(t.versionFile, { force: true });
+    // 3) Bloques marcados
+    removeMarkedBlock(t.claudeMd, BEGIN, END);
+    removeMarkedBlock(t.gitignore, GI_BEGIN, GI_END);
+    // 4) Hooks + permisos del arnés en settings.json (por cadena exacta)
+    removeHarnessSettings(t.settingsFile);
+    // 5) state/ y config/ NO se tocan — son del consumidor
+    console.log('✓ Desinstalado. Se conservaron .claude/state/ y .claude/config/ (estado y allowlist del equipo).');
+}
+const BEGIN = '<!-- BEGIN trycore-build-harness ';
+const END = '<!-- END trycore-build-harness -->';
+const GI_BEGIN = '# ── trycore-build-harness (auto)';
+const GI_END = '# ── /trycore-build-harness';
+function isSymlink(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/update.js

@@ -0,0 +1,11 @@
+// commands/update.ts — refresca la instalación. Alias de `init --update` (no interactivo).
+// Nunca pisa build-state.json ni stack-allowlist.json (el estado/config son del consumidor).
+import { init } from './init.js';
+export async function update(opts) {
+    await init({
+        targetDir: opts.targetDir,
+        mode: 'update',
+        useCopy: opts.useCopy,
+        skipDoctor: opts.skipDoctor,
+    });
+}

package/dist/lib/install-engine.js

@@ -0,0 +1,99 @@
+// install-engine.ts — núcleo de instalación: link/copy de assets a .claude/.
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Asegura el bit ejecutable (0755) en un archivo o en todos los archivos de un dir.
+ * Necesario tras `copy` porque fs.copyFileSync no preserva el modo de forma fiable
+ * cross-platform — los hooks bash fallarían silenciosamente sin +x.
+ */
+export function chmodExec(target) {
+    if (!fs.existsSync(target))
+        return;
+    const stat = fs.statSync(target);
+    if (stat.isDirectory()) {
+        for (const entry of fs.readdirSync(target)) {
+            chmodExec(path.join(target, entry));
+        }
+    }
+    else {
+        fs.chmodSync(target, 0o755);
+    }
+}
+/**
+ * Garantiza que un directorio exista.
+ */
+export function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+/**
+ * Crea symlink (o copia) desde src a dst.
+ * Si dst ya existe (file, dir o symlink), lo reemplaza.
+ */
+export function linkOrCopy(src, dst, mode) {
+    ensureDir(path.dirname(dst));
+    // Limpiar destino existente
+    if (fs.existsSync(dst) || isSymlink(dst)) {
+        fs.rmSync(dst, { recursive: true, force: true });
+    }
+    if (mode === 'symlink') {
+        // Symlink absoluto (más portable que relativo, especialmente entre máquinas con el mismo paquete global)
+        fs.symlinkSync(src, dst, fs.statSync(src).isDirectory() ? 'dir' : 'file');
+    }
+    else {
+        if (fs.statSync(src).isDirectory()) {
+            copyDirRecursive(src, dst);
+        }
+        else {
+            fs.copyFileSync(src, dst);
+        }
+    }
+}
+function isSymlink(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function copyDirRecursive(src, dst) {
+    ensureDir(dst);
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const dstPath = path.join(dst, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, dstPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, dstPath);
+        }
+    }
+}
+/**
+ * Para cada subdirectorio en `srcRoot`, instala bajo `dstParent/<name>` (symlink o copy).
+ * Útil para skills/ donde cada subcarpeta es una skill.
+ */
+export function linkChildren(srcRoot, dstParent, mode, filter = () => true) {
+    if (!fs.existsSync(srcRoot))
+        return 0;
+    ensureDir(dstParent);
+    let count = 0;
+    for (const entry of fs.readdirSync(srcRoot, { withFileTypes: true })) {
+        if (!filter(entry.name))
+            continue;
+        const src = path.join(srcRoot, entry.name);
+        const dst = path.join(dstParent, entry.name);
+        linkOrCopy(src, dst, mode);
+        count++;
+    }
+    return count;
+}
+/**
+ * Cuenta cuántos hijos visibles tiene un directorio (para reportes).
+ */
+export function countChildren(dir) {
+    if (!fs.existsSync(dir))
+        return 0;
+    return fs.readdirSync(dir).filter((n) => !n.startsWith('.')).length;
+}

package/dist/lib/markers.js

@@ -0,0 +1,81 @@
+// markers.ts — inserta/reemplaza bloques marcados dentro de archivos de texto.
+// Usado para CLAUDE.md y .gitignore. Idempotente.
+import fs from 'node:fs';
+/**
+ * Si el archivo ya contiene el bloque (detectado por beginMarker), lo reemplaza.
+ * Si no, anexa el bloque al final del archivo (con una línea en blanco antes si tenía contenido).
+ * Si el archivo no existe, lo crea con solo el blockContent.
+ */
+export function upsertMarkedBlock(opts) {
+    const { beginMarker, endMarker, blockContent, filePath } = opts;
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, blockContent + '\n', 'utf8');
+        return 'created';
+    }
+    const existing = fs.readFileSync(filePath, 'utf8');
+    const lines = existing.split('\n');
+    const beginIdx = lines.findIndex((l) => l.includes(beginMarker));
+    if (beginIdx === -1) {
+        // No existe el bloque: anexar al final
+        const sep = existing.endsWith('\n') ? '' : '\n';
+        const prefix = existing.length > 0 ? '\n' : '';
+        fs.writeFileSync(filePath, existing + sep + prefix + blockContent + '\n', 'utf8');
+        return 'appended';
+    }
+    // Buscar la línea de fin desde beginIdx
+    let endIdx = -1;
+    for (let i = beginIdx; i < lines.length; i++) {
+        if (lines[i].includes(endMarker)) {
+            endIdx = i;
+            break;
+        }
+    }
+    if (endIdx === -1) {
+        // Hay begin pero no end — archivo corrupto. Anexar al final como recovery.
+        const sep = existing.endsWith('\n') ? '' : '\n';
+        fs.writeFileSync(filePath, existing + sep + '\n' + blockContent + '\n', 'utf8');
+        return 'appended';
+    }
+    const before = lines.slice(0, beginIdx).join('\n');
+    const after = lines.slice(endIdx + 1).join('\n');
+    const blockLines = blockContent.split('\n');
+    const merged = [
+        ...(before.length > 0 ? [before] : []),
+        ...blockLines,
+        ...(after.length > 0 ? [after] : []),
+    ].join('\n');
+    fs.writeFileSync(filePath, merged.endsWith('\n') ? merged : merged + '\n', 'utf8');
+    return 'replaced';
+}
+/**
+ * Elimina un bloque marcado (begin..end inclusive). Si no existe, no hace nada.
+ * Devuelve true si removió algo.
+ */
+export function removeMarkedBlock(filePath, beginMarker, endMarker) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const existing = fs.readFileSync(filePath, 'utf8');
+    const lines = existing.split('\n');
+    const beginIdx = lines.findIndex((l) => l.includes(beginMarker));
+    if (beginIdx === -1)
+        return false;
+    let endIdx = -1;
+    for (let i = beginIdx; i < lines.length; i++) {
+        if (lines[i].includes(endMarker)) {
+            endIdx = i;
+            break;
+        }
+    }
+    if (endIdx === -1)
+        return false;
+    // Remover beginIdx..endIdx, y limpiar 1 línea en blanco antes/después si la hay
+    let removeStart = beginIdx;
+    let removeEnd = endIdx + 1;
+    if (removeStart > 0 && lines[removeStart - 1].trim() === '')
+        removeStart--;
+    if (removeEnd < lines.length && lines[removeEnd].trim() === '')
+        removeEnd++;
+    const remaining = [...lines.slice(0, removeStart), ...lines.slice(removeEnd)].join('\n');
+    fs.writeFileSync(filePath, remaining, 'utf8');
+    return true;
+}

package/dist/lib/paths.js

@@ -0,0 +1,65 @@
+// paths.ts — resuelve el directorio raíz del paquete instalado.
+// Cuando el CLI corre como `trycore-build`, __dirname apunta a <pkg>/dist/lib.
+// El paquete raíz está dos niveles arriba: <pkg>/dist/lib → <pkg>/.
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/** Raíz del paquete instalado (donde viven agents/, skills/, hooks/, etc.) */
+export const PACKAGE_ROOT = path.resolve(__dirname, '..', '..');
+/** Versión leída desde el archivo VERSION del paquete. */
+export function readPackageVersion() {
+    const versionFile = path.join(PACKAGE_ROOT, 'VERSION');
+    if (fs.existsSync(versionFile)) {
+        return fs.readFileSync(versionFile, 'utf8').trim();
+    }
+    const pkgFile = path.join(PACKAGE_ROOT, 'package.json');
+    if (fs.existsSync(pkgFile)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    return '0.0.0';
+}
+/**
+ * Rutas convencionales dentro del paquete (origen de los assets a instalar).
+ * El harness preserva sus rutas NATIVAS (agents/build, commands/opsx, …) — NO se
+ * reubica bajo un namespace envolvente, porque sus archivos se auto-referencian por ruta.
+ */
+export const ASSETS = {
+    agentsBuild: path.join(PACKAGE_ROOT, 'agents', 'build'),
+    commandsOpsx: path.join(PACKAGE_ROOT, 'commands', 'opsx'),
+    commandsBuild: path.join(PACKAGE_ROOT, 'commands', 'build'),
+    skills: path.join(PACKAGE_ROOT, 'skills'),
+    hooksBuild: path.join(PACKAGE_ROOT, 'hooks', 'build'),
+    // Declaración de hooks para el canal PLUGIN (no la instala el CLI; la consume el plugin nativo).
+    pluginHooks: path.join(PACKAGE_ROOT, 'hooks', 'build-harness.json'),
+    stateSchema: path.join(PACKAGE_ROOT, 'state', 'build-state.schema.json'),
+    stateReadme: path.join(PACKAGE_ROOT, 'state', 'README.md'),
+    stateTemplate: path.join(PACKAGE_ROOT, 'state', 'build-state.template.json'),
+    configTemplate: path.join(PACKAGE_ROOT, 'config', 'stack-allowlist.template.json'),
+    templateClaudeMd: path.join(PACKAGE_ROOT, 'templates', 'CLAUDE.md.template'),
+    settingsHooksTemplate: path.join(PACKAGE_ROOT, 'templates', 'settings-hooks.template.json'),
+};
+/** Rutas dentro del proyecto consumidor (relativas a `targetDir`). */
+export function targetPaths(targetDir) {
+    const claudeDir = path.join(targetDir, '.claude');
+    return {
+        claudeDir,
+        agentsBuild: path.join(claudeDir, 'agents', 'build'),
+        commandsOpsx: path.join(claudeDir, 'commands', 'opsx'),
+        commandsBuild: path.join(claudeDir, 'commands', 'build'),
+        skillsDir: path.join(claudeDir, 'skills'),
+        hooksBuild: path.join(claudeDir, 'hooks', 'build'),
+        configDir: path.join(claudeDir, 'config'),
+        configFile: path.join(claudeDir, 'config', 'stack-allowlist.json'),
+        stateDir: path.join(claudeDir, 'state'),
+        stateSchema: path.join(claudeDir, 'state', 'build-state.schema.json'),
+        stateReadme: path.join(claudeDir, 'state', 'README.md'),
+        stateFile: path.join(claudeDir, 'state', 'build-state.json'),
+        settingsFile: path.join(claudeDir, 'settings.json'),
+        versionFile: path.join(claudeDir, '.build-harness-version'),
+        claudeMd: path.join(targetDir, 'CLAUDE.md'),
+        gitignore: path.join(targetDir, '.gitignore'),
+    };
+}

package/dist/lib/settings-merge.js

@@ -0,0 +1,125 @@
+// settings-merge.ts — merge idempotente de hooks + permisos mínimos en el
+// settings.json del consumidor (canal npm CLI). Fuente de verdad de las entradas.
+//
+// Diseño (corrige el doble disparo [H3] y la remoción frágil [M3]):
+//  - UNA cadena de comando autorresolutiva, IDÉNTICA a la del canal plugin
+//    (hooks/build-harness.json). Si el consumidor instala por CLI Y por plugin,
+//    las cadenas son idénticas → Claude Code las deduplica → el hook dispara UNA vez.
+//  - Remoción por set EXACTO de cadenas conocidas (no substring de ruta).
+import fs from 'node:fs';
+// Cadena autorresolutiva: con plugin → ${CLAUDE_PLUGIN_ROOT}/hooks/build/…;
+// sin plugin (CLI puro) → $CLAUDE_PROJECT_DIR/.claude/hooks/build/…
+const CHAIN = '${CLAUDE_PLUGIN_ROOT:-$CLAUDE_PROJECT_DIR/.claude}/hooks/build/';
+/** Construye la cadena de comando (entre comillas, para rutas con espacios). */
+function cmd(script) {
+    return `"${CHAIN}${script}"`;
+}
+/** Las 5 agrupaciones de hooks del arnés (= las de hooks/build-harness.json). */
+const HOOK_SPECS = [
+    { event: 'SessionStart', matcher: 'startup|clear|compact', scripts: ['load-build-state.sh'] },
+    { event: 'PreToolUse', matcher: 'Bash', scripts: ['gitflow-guard.sh'] },
+    { event: 'PreToolUse', matcher: 'Write|Edit|MultiEdit', scripts: ['stack-guard.sh'] },
+    { event: 'PostToolUse', matcher: 'Write|Edit|MultiEdit', scripts: ['lint-typecheck.sh', 'coherence-flag.sh'] },
+    { event: 'Stop', matcher: '.*', scripts: ['build-gate-check.sh'] },
+];
+/** Permisos MÍNIMOS y enumerados [H11]. Nunca permisos amplios (mcp__*, additionalDirectories…). */
+const MIN_PERMISSIONS = [
+    'Bash(openspec validate *)',
+    'Bash(openspec list *)',
+    'Bash(openspec show *)',
+];
+/** Todas las cadenas de comando que este paquete inyecta (para remoción exacta). */
+function ownedCommands() {
+    const set = new Set();
+    for (const spec of HOOK_SPECS)
+        for (const s of spec.scripts)
+            set.add(cmd(s));
+    return set;
+}
+function readSettings(file) {
+    if (!fs.existsSync(file))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new Error(`settings.json malformado: ${file}. Corrígelo o muévelo antes de reintentar.`);
+    }
+}
+function writeSettings(file, s) {
+    fs.writeFileSync(file, JSON.stringify(s, null, 2) + '\n', 'utf8');
+}
+function existingCommands(settings, event) {
+    const out = new Set();
+    for (const group of settings.hooks?.[event] ?? []) {
+        for (const h of group.hooks ?? [])
+            out.add(h.command);
+    }
+    return out;
+}
+/** Mergea hooks + permisos mínimos. Idempotente; aditivo (no pisa lo del consumidor). */
+export function mergeHarnessSettings(settingsFile) {
+    const settings = readSettings(settingsFile);
+    settings.hooks ??= {};
+    let addedHooks = 0;
+    for (const spec of HOOK_SPECS) {
+        const present = existingCommands(settings, spec.event);
+        const newHooks = spec.scripts
+            .filter((s) => !present.has(cmd(s)))
+            .map((s) => ({ type: 'command', command: cmd(s) }));
+        if (newHooks.length === 0)
+            continue;
+        settings.hooks[spec.event] ??= [];
+        settings.hooks[spec.event].push({ matcher: spec.matcher, hooks: newHooks });
+        addedHooks += newHooks.length;
+    }
+    settings.permissions ??= {};
+    settings.permissions.allow ??= [];
+    const allow = settings.permissions.allow;
+    let addedPerms = 0;
+    for (const p of MIN_PERMISSIONS) {
+        if (!allow.includes(p)) {
+            allow.push(p);
+            addedPerms++;
+        }
+    }
+    writeSettings(settingsFile, settings);
+    return { addedHooks, addedPerms };
+}
+/** Quita SOLO lo que este paquete inyectó (por cadena exacta). Preserva lo demás. */
+export function removeHarnessSettings(settingsFile) {
+    if (!fs.existsSync(settingsFile))
+        return false;
+    const settings = readSettings(settingsFile);
+    const owned = ownedCommands();
+    let changed = false;
+    if (settings.hooks) {
+        for (const event of Object.keys(settings.hooks)) {
+            const groups = settings.hooks[event];
+            for (const group of groups) {
+                const before = group.hooks?.length ?? 0;
+                if (group.hooks)
+                    group.hooks = group.hooks.filter((h) => !owned.has(h.command));
+                if ((group.hooks?.length ?? 0) !== before)
+                    changed = true;
+            }
+            // Drop grupos sin hooks
+            settings.hooks[event] = groups.filter((g) => (g.hooks?.length ?? 0) > 0);
+            if (settings.hooks[event].length === 0)
+                delete settings.hooks[event];
+        }
+        if (Object.keys(settings.hooks).length === 0)
+            delete settings.hooks;
+    }
+    if (settings.permissions?.allow) {
+        const allow = settings.permissions.allow;
+        const filtered = allow.filter((p) => !MIN_PERMISSIONS.includes(p));
+        if (filtered.length !== allow.length) {
+            settings.permissions.allow = filtered;
+            changed = true;
+        }
+    }
+    if (changed)
+        writeSettings(settingsFile, settings);
+    return changed;
+}

package/dist/lib/stack-prompt.js

@@ -0,0 +1,69 @@
+// stack-prompt.ts — captura el STACK MECÁNICO del consumidor (capa CLI del onboarding).
+// Los parámetros de JUICIO (PII, capa IA/externa, capa determinista) NO se capturan aquí:
+// los resuelve el slash command /build:onboard, ejecutado por Claude leyendo el PRD [H5,H8].
+//
+// CI-safe [H6]: si no hay TTY o se pasa --yes, usa defaults sin bloquear.
+import * as readline from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+const DEFAULTS = {
+    pkgManager: 'npm',
+    runtime: '>=18.18',
+    prdPath: 'docs/01-prd/<tu-prd>.md#requisitos-tecnicos',
+};
+function parseList(s) {
+    if (!s)
+        return [];
+    return s
+        .split(',')
+        .map((x) => x.trim())
+        .filter(Boolean);
+}
+/** ¿Podemos preguntar interactivamente? Solo si hay TTY y no se pidió --yes. */
+function canPrompt(flags) {
+    return !flags.yes && Boolean(stdin.isTTY) && Boolean(stdout.isTTY);
+}
+export async function captureStack(flags) {
+    // Si todos los datos vienen por flags, no preguntamos.
+    const haveAll = flags.stack !== undefined && flags.pkgManager && flags.runtime && flags.prdPath;
+    if (haveAll || !canPrompt(flags)) {
+        return {
+            cfg: {
+                allow: parseList(flags.stack),
+                pkgManager: flags.pkgManager ?? DEFAULTS.pkgManager,
+                runtime: flags.runtime ?? DEFAULTS.runtime,
+                prdPath: flags.prdPath ?? DEFAULTS.prdPath,
+            },
+            interactive: false,
+        };
+    }
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+        stdout.write('\n  Configuración del stack (Enter para usar el valor por defecto):\n');
+        const allowRaw = flags.stack ?? (await rl.question('  Dependencias/paquetes permitidos (coma-separadas) []: '));
+        const pkgManager = flags.pkgManager || (await rl.question(`  Package manager [${DEFAULTS.pkgManager}]: `)) || DEFAULTS.pkgManager;
+        const runtime = flags.runtime || (await rl.question(`  Runtime (semver del motor) [${DEFAULTS.runtime}]: `)) || DEFAULTS.runtime;
+        const prdPath = flags.prdPath ||
+            (await rl.question(`  Ruta#ancla del PRD técnico [${DEFAULTS.prdPath}]: `)) ||
+            DEFAULTS.prdPath;
+        return {
+            cfg: { allow: parseList(allowRaw), pkgManager, runtime, prdPath },
+            interactive: true,
+        };
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Renderiza el contenido de stack-allowlist.json desde el stack capturado. */
+export function renderAllowlist(cfg) {
+    return {
+        _comment: 'Allowlist de dependencias del proyecto. Derivada de la sección de requisitos técnicos del PRD. ' +
+            'El hook stack-guard.sh bloquea dependencias fuera de `allow` al editar package.json.',
+        source: cfg.prdPath,
+        version: '1.0',
+        runtime: { node: cfg.runtime, packageManager: cfg.pkgManager },
+        allow: cfg.allow,
+        deny_examples: [],
+        rationale: {},
+    };
+}

package/dist/lib/state-seed.js

@@ -0,0 +1,59 @@
+// state-seed.ts — siembra el estado del arnés en el consumidor.
+// Política [C1]: schema + README se VERSIONAN y refrescan en cada init/update;
+// el estado vivo (build-state.json) se siembra UNA vez desde un template VACÍO
+// y NUNCA se sobreescribe (es propiedad del equipo).
+import fs from 'node:fs';
+import path from 'node:path';
+import { ASSETS, targetPaths } from './paths.js';
+import { ensureDir } from './install-engine.js';
+/** Estado inicial vacío (fallback si falta el template del paquete). */
+const EMPTY_STATE = {
+    version: '1.0',
+    harness_phase: 'authoring',
+    active_slice: null,
+    history: [],
+    releases: [],
+};
+export function seedState(targetDir) {
+    const t = targetPaths(targetDir);
+    ensureDir(t.stateDir);
+    // schema + README: assets versionados, se refrescan siempre.
+    if (fs.existsSync(ASSETS.stateSchema))
+        fs.copyFileSync(ASSETS.stateSchema, t.stateSchema);
+    if (fs.existsSync(ASSETS.stateReadme))
+        fs.copyFileSync(ASSETS.stateReadme, t.stateReadme);
+    // build-state.json: solo si NO existe. Si existe, intacto.
+    let stateSeeded = false;
+    if (!fs.existsSync(t.stateFile)) {
+        if (fs.existsSync(ASSETS.stateTemplate)) {
+            fs.copyFileSync(ASSETS.stateTemplate, t.stateFile);
+        }
+        else {
+            fs.writeFileSync(t.stateFile, JSON.stringify(EMPTY_STATE, null, 2) + '\n', 'utf8');
+        }
+        stateSeeded = true;
+    }
+    return { stateSeeded };
+}
+/**
+ * Siembra el stack-allowlist.json del consumidor (artefacto del consumidor, no del paquete).
+ * Solo si NO existe. Acepta un objeto ya resuelto con el stack capturado por el CLI;
+ * si es null, copia el template tal cual.
+ */
+export function seedConfig(targetDir, allowlist) {
+    const t = targetPaths(targetDir);
+    ensureDir(t.configDir);
+    if (fs.existsSync(t.configFile))
+        return { configSeeded: false };
+    if (allowlist) {
+        fs.writeFileSync(t.configFile, JSON.stringify(allowlist, null, 2) + '\n', 'utf8');
+    }
+    else if (fs.existsSync(ASSETS.configTemplate)) {
+        fs.copyFileSync(ASSETS.configTemplate, t.configFile);
+    }
+    else {
+        return { configSeeded: false };
+    }
+    void path;
+    return { configSeeded: true };
+}