@trycore/spec-build-harness 0.1.0

package/commands/opsx/sync.md

@@ -0,0 +1,134 @@
+---
+name: "OPSX: Sync"
+description: Sync delta specs from a change to main specs
+category: Workflow
+tags: [workflow, specs, experimental]
+---
+
+Sync delta specs from a change to main specs.
+
+This is an **agent-driven** operation - you will read delta specs and directly edit main specs to apply the changes. This allows intelligent merging (e.g., adding a scenario without copying the entire requirement).
+
+**Input**: Optionally specify a change name after `/opsx:sync` (e.g., `/opsx:sync add-auth`). If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
+
+**Steps**
+
+1. **If no change name provided, prompt for selection**
+
+   Run `openspec list --json` to get available changes. Use the **AskUserQuestion tool** to let the user select.
+
+   Show changes that have delta specs (under `specs/` directory).
+
+   **IMPORTANT**: Do NOT guess or auto-select a change. Always let the user choose.
+
+2. **Find delta specs**
+
+   Look for delta spec files in `openspec/changes/<name>/specs/*/spec.md`.
+
+   Each delta spec file contains sections like:
+   - `## ADDED Requirements` - New requirements to add
+   - `## MODIFIED Requirements` - Changes to existing requirements
+   - `## REMOVED Requirements` - Requirements to remove
+   - `## RENAMED Requirements` - Requirements to rename (FROM:/TO: format)
+
+   If no delta specs found, inform user and stop.
+
+3. **For each delta spec, apply changes to main specs**
+
+   For each capability with a delta spec at `openspec/changes/<name>/specs/<capability>/spec.md`:
+
+   a. **Read the delta spec** to understand the intended changes
+
+   b. **Read the main spec** at `openspec/specs/<capability>/spec.md` (may not exist yet)
+
+   c. **Apply changes intelligently**:
+
+      **ADDED Requirements:**
+      - If requirement doesn't exist in main spec → add it
+      - If requirement already exists → update it to match (treat as implicit MODIFIED)
+
+      **MODIFIED Requirements:**
+      - Find the requirement in main spec
+      - Apply the changes - this can be:
+        - Adding new scenarios (don't need to copy existing ones)
+        - Modifying existing scenarios
+        - Changing the requirement description
+      - Preserve scenarios/content not mentioned in the delta
+
+      **REMOVED Requirements:**
+      - Remove the entire requirement block from main spec
+
+      **RENAMED Requirements:**
+      - Find the FROM requirement, rename to TO
+
+   d. **Create new main spec** if capability doesn't exist yet:
+      - Create `openspec/specs/<capability>/spec.md`
+      - Add Purpose section (can be brief, mark as TBD)
+      - Add Requirements section with the ADDED requirements
+
+4. **Show summary**
+
+   After applying all changes, summarize:
+   - Which capabilities were updated
+   - What changes were made (requirements added/modified/removed/renamed)
+
+**Delta Spec Format Reference**
+
+```markdown
+## ADDED Requirements
+
+### Requirement: New Feature
+The system SHALL do something new.
+
+#### Scenario: Basic case
+- **WHEN** user does X
+- **THEN** system does Y
+
+## MODIFIED Requirements
+
+### Requirement: Existing Feature
+#### Scenario: New scenario to add
+- **WHEN** user does A
+- **THEN** system does B
+
+## REMOVED Requirements
+
+### Requirement: Deprecated Feature
+
+## RENAMED Requirements
+
+- FROM: `### Requirement: Old Name`
+- TO: `### Requirement: New Name`
+```
+
+**Key Principle: Intelligent Merging**
+
+Unlike programmatic merging, you can apply **partial updates**:
+- To add a scenario, just include that scenario under MODIFIED - don't copy existing scenarios
+- The delta represents *intent*, not a wholesale replacement
+- Use your judgment to merge changes sensibly
+
+**Output On Success**
+
+```
+## Specs Synced: <change-name>
+
+Updated main specs:
+
+**<capability-1>**:
+- Added requirement: "New Feature"
+- Modified requirement: "Existing Feature" (added 1 scenario)
+
+**<capability-2>**:
+- Created new spec file
+- Added requirement: "Another Feature"
+
+Main specs are now updated. The change remains active - archive when implementation is complete.
+```
+
+**Guardrails**
+- Read both delta and main specs before making changes
+- Preserve existing content not mentioned in delta
+- If something is unclear, ask for clarification
+- Show what you're changing as you go
+- The operation should be idempotent - running twice should give same result

package/commands/opsx/verify.md

@@ -0,0 +1,164 @@
+---
+name: "OPSX: Verify"
+description: Verify implementation matches change artifacts before archiving
+category: Workflow
+tags: [workflow, verify, experimental]
+---
+
+Verify that an implementation matches the change artifacts (specs, tasks, design).
+
+**Input**: Optionally specify a change name after `/opsx:verify` (e.g., `/opsx:verify add-auth`). If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
+
+**Steps**
+
+1. **If no change name provided, prompt for selection**
+
+   Run `openspec list --json` to get available changes. Use the **AskUserQuestion tool** to let the user select.
+
+   Show changes that have implementation tasks (tasks artifact exists).
+   Include the schema used for each change if available.
+   Mark changes with incomplete tasks as "(In Progress)".
+
+   **IMPORTANT**: Do NOT guess or auto-select a change. Always let the user choose.
+
+2. **Check status to understand the schema**
+   ```bash
+   openspec status --change "<name>" --json
+   ```
+   Parse the JSON to understand:
+   - `schemaName`: The workflow being used (e.g., "spec-driven")
+   - Which artifacts exist for this change
+
+3. **Get the change directory and load artifacts**
+
+   ```bash
+   openspec instructions apply --change "<name>" --json
+   ```
+
+   This returns the change directory and context files. Read all available artifacts from `contextFiles`.
+
+4. **Initialize verification report structure**
+
+   Create a report structure with three dimensions:
+   - **Completeness**: Track tasks and spec coverage
+   - **Correctness**: Track requirement implementation and scenario coverage
+   - **Coherence**: Track design adherence and pattern consistency
+
+   Each dimension can have CRITICAL, WARNING, or SUGGESTION issues.
+
+5. **Verify Completeness**
+
+   **Task Completion**:
+   - If tasks.md exists in contextFiles, read it
+   - Parse checkboxes: `- [ ]` (incomplete) vs `- [x]` (complete)
+   - Count complete vs total tasks
+   - If incomplete tasks exist:
+     - Add CRITICAL issue for each incomplete task
+     - Recommendation: "Complete task: <description>" or "Mark as done if already implemented"
+
+   **Spec Coverage**:
+   - If delta specs exist in `openspec/changes/<name>/specs/`:
+     - Extract all requirements (marked with "### Requirement:")
+     - For each requirement:
+       - Search codebase for keywords related to the requirement
+       - Assess if implementation likely exists
+     - If requirements appear unimplemented:
+       - Add CRITICAL issue: "Requirement not found: <requirement name>"
+       - Recommendation: "Implement requirement X: <description>"
+
+6. **Verify Correctness**
+
+   **Requirement Implementation Mapping**:
+   - For each requirement from delta specs:
+     - Search codebase for implementation evidence
+     - If found, note file paths and line ranges
+     - Assess if implementation matches requirement intent
+     - If divergence detected:
+       - Add WARNING: "Implementation may diverge from spec: <details>"
+       - Recommendation: "Review <file>:<lines> against requirement X"
+
+   **Scenario Coverage**:
+   - For each scenario in delta specs (marked with "#### Scenario:"):
+     - Check if conditions are handled in code
+     - Check if tests exist covering the scenario
+     - If scenario appears uncovered:
+       - Add WARNING: "Scenario not covered: <scenario name>"
+       - Recommendation: "Add test or implementation for scenario: <description>"
+
+7. **Verify Coherence**
+
+   **Design Adherence**:
+   - If design.md exists in contextFiles:
+     - Extract key decisions (look for sections like "Decision:", "Approach:", "Architecture:")
+     - Verify implementation follows those decisions
+     - If contradiction detected:
+       - Add WARNING: "Design decision not followed: <decision>"
+       - Recommendation: "Update implementation or revise design.md to match reality"
+   - If no design.md: Skip design adherence check, note "No design.md to verify against"
+
+   **Code Pattern Consistency**:
+   - Review new code for consistency with project patterns
+   - Check file naming, directory structure, coding style
+   - If significant deviations found:
+     - Add SUGGESTION: "Code pattern deviation: <details>"
+     - Recommendation: "Consider following project pattern: <example>"
+
+8. **Generate Verification Report**
+
+   **Summary Scorecard**:
+   ```
+   ## Verification Report: <change-name>
+
+   ### Summary
+   | Dimension    | Status           |
+   |--------------|------------------|
+   | Completeness | X/Y tasks, N reqs|
+   | Correctness  | M/N reqs covered |
+   | Coherence    | Followed/Issues  |
+   ```
+
+   **Issues by Priority**:
+
+   1. **CRITICAL** (Must fix before archive):
+      - Incomplete tasks
+      - Missing requirement implementations
+      - Each with specific, actionable recommendation
+
+   2. **WARNING** (Should fix):
+      - Spec/design divergences
+      - Missing scenario coverage
+      - Each with specific recommendation
+
+   3. **SUGGESTION** (Nice to fix):
+      - Pattern inconsistencies
+      - Minor improvements
+      - Each with specific recommendation
+
+   **Final Assessment**:
+   - If CRITICAL issues: "X critical issue(s) found. Fix before archiving."
+   - If only warnings: "No critical issues. Y warning(s) to consider. Ready for archive (with noted improvements)."
+   - If all clear: "All checks passed. Ready for archive."
+
+**Verification Heuristics**
+
+- **Completeness**: Focus on objective checklist items (checkboxes, requirements list)
+- **Correctness**: Use keyword search, file path analysis, reasonable inference - don't require perfect certainty
+- **Coherence**: Look for glaring inconsistencies, don't nitpick style
+- **False Positives**: When uncertain, prefer SUGGESTION over WARNING, WARNING over CRITICAL
+- **Actionability**: Every issue must have a specific recommendation with file/line references where applicable
+
+**Graceful Degradation**
+
+- If only tasks.md exists: verify task completion only, skip spec/design checks
+- If tasks + specs exist: verify completeness and correctness, skip design
+- If full artifacts: verify all three dimensions
+- Always note which checks were skipped and why
+
+**Output Format**
+
+Use clear markdown with:
+- Table for summary scorecard
+- Grouped lists for issues (CRITICAL/WARNING/SUGGESTION)
+- Code references in format: `file.ts:123`
+- Specific, actionable recommendations
+- No vague suggestions like "consider reviewing"

package/config/stack-allowlist.template.json

@@ -0,0 +1,12 @@
+{
+  "_comment": "TEMPLATE. trycore-build init lo materializa en .claude/config/stack-allowlist.json del consumidor. El hook stack-guard.sh bloquea dependencias fuera de `allow` al editar package.json. Pueblalo con tu stack (o corre /build:onboard).",
+  "source": "docs/01-prd/<tu-prd>.md#requisitos-tecnicos",
+  "version": "1.0",
+  "runtime": {
+    "node": ">=18.18",
+    "packageManager": "npm|pnpm|yarn"
+  },
+  "allow": [],
+  "deny_examples": [],
+  "rationale": {}
+}

package/dist/cli.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// cli.ts — entry point del CLI `trycore-build`.
+import { Command } from 'commander';
+import { readPackageVersion } from './lib/paths.js';
+import { init } from './commands/init.js';
+import { update } from './commands/update.js';
+import { status } from './commands/status.js';
+import { uninstall } from './commands/uninstall.js';
+import { doctor } from './commands/doctor.js';
+const program = new Command();
+program
+    .name('trycore-build')
+    .description('Arnés de construcción de Trycore para Claude Code: pipeline de dos loops (slice por épica + release gate) con gates de calidad, estado compartido y OpenSpec.')
+    .version(readPackageVersion(), '-v, --version', 'imprime la versión del paquete');
+program
+    .command('init')
+    .description('Instala el arnés en el directorio actual (o el indicado). Idempotente.')
+    .argument('[directory]', 'Directorio donde instalar', '.')
+    .option('--copy', 'Copiar archivos en vez de symlinkear (Windows sin admin, sandboxes)')
+    .option('--force-init', 'Fuerza modo init incluso si ya hay instalación previa')
+    .option('--skip-doctor', 'Omite la verificación de openspec/python3/git (no recomendado)')
+    .option('--stack <deps>', 'Dependencias permitidas, coma-separadas (no interactivo)')
+    .option('--pkg-manager <pm>', 'Package manager (npm|pnpm|yarn)')
+    .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')
+    .action(async (directory, opts) => {
+    try {
+        await init({
+            targetDir: directory,
+            mode: opts.forceInit ? 'init' : 'auto',
+            useCopy: Boolean(opts.copy),
+            skipDoctor: Boolean(opts.skipDoctor),
+            stackFlags: {
+                stack: opts.stack,
+                pkgManager: opts.pkgManager,
+                runtime: opts.runtime,
+                prdPath: opts.prdPath,
+                yes: Boolean(opts.yes),
+            },
+        });
+    }
+    catch (err) {
+        console.error('✗ Error:', err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('update')
+    .description('Refresca assets y schema tras actualizar el paquete npm. No pisa estado ni allowlist.')
+    .argument('[directory]', 'Directorio del proyecto', '.')
+    .option('--copy', 'Copiar archivos en vez de symlinkear')
+    .option('--skip-doctor', 'Omite la verificación de requisitos externos')
+    .action(async (directory, opts) => {
+    try {
+        await update({ targetDir: directory, useCopy: Boolean(opts.copy), skipDoctor: Boolean(opts.skipDoctor) });
+    }
+    catch (err) {
+        console.error('✗ Error:', err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('status')
+    .description('Muestra el estado de la instalación y la fase del arnés.')
+    .argument('[directory]', 'Directorio del proyecto', '.')
+    .action(async (directory) => {
+    try {
+        await status({ targetDir: directory });
+    }
+    catch (err) {
+        console.error('✗ Error:', err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('uninstall')
+    .description('Quita el arnés del proyecto. NO toca .claude/state/ ni .claude/config/.')
+    .argument('[directory]', 'Directorio del proyecto', '.')
+    .action(async (directory) => {
+    try {
+        await uninstall({ targetDir: directory });
+    }
+    catch (err) {
+        console.error('✗ Error:', err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('doctor')
+    .description('Verifica requisitos externos (openspec/python3/git), hooks ejecutables y canales.')
+    .argument('[directory]', 'Directorio del proyecto', '.')
+    .action(async (directory) => {
+    try {
+        await doctor({ targetDir: directory });
+    }
+    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

@@ -0,0 +1,77 @@
+// commands/doctor.ts — diagnóstico de requisitos del arnés.
+// El harness depende de binarios EXTERNOS que el CLI no puede instalar:
+//   - openspec  → columna vertebral de /opsx:* y skills openspec-* [C2]
+//   - python3   → los hooks parsean JSON con python3 [H4]
+//   - git       → los hooks y gitflow-guard resuelven la raíz con git rev-parse
+// doctor FALLA (exit 1) si falta un requisito duro.
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { targetPaths } from '../lib/paths.js';
+export function hasBinary(bin) {
+    if (process.platform === 'win32') {
+        return spawnSync('where', [bin], { stdio: 'ignore' }).status === 0;
+    }
+    return spawnSync('sh', ['-c', `command -v ${bin}`], { stdio: 'ignore' }).status === 0;
+}
+/** Chequea las dependencias externas duras. */
+export function checkDeps() {
+    const git = hasBinary('git');
+    const python3 = hasBinary('python3');
+    const openspec = hasBinary('openspec');
+    const missingHard = [];
+    if (!git)
+        missingHard.push('git');
+    if (!python3)
+        missingHard.push('python3');
+    if (!openspec)
+        missingHard.push('openspec');
+    return { git, python3, openspec, missingHard };
+}
+export async function doctor(opts) {
+    const targetDir = path.resolve(opts.targetDir);
+    const t = targetPaths(targetDir);
+    const dep = checkDeps();
+    console.log('════════ trycore-build doctor ════════');
+    console.log(`Proyecto: ${targetDir}`);
+    console.log('');
+    console.log('Requisitos externos:');
+    console.log(`  git:       ${dep.git ? '✓' : '✗ FALTA'}`);
+    console.log(`  python3:   ${dep.python3 ? '✓' : '✗ FALTA (los hooks lo necesitan para parsear JSON)'}`);
+    console.log(`  openspec:  ${dep.openspec ? '✓' : '✗ FALTA (npm i -g @fission-ai/openspec — requerido por /opsx:* y skills openspec-*)'}`);
+    // Hooks ejecutables
+    console.log('');
+    console.log('Hooks instalados:');
+    if (fs.existsSync(t.hooksBuild)) {
+        const scripts = fs.readdirSync(t.hooksBuild).filter((f) => f.endsWith('.sh'));
+        let nonExec = 0;
+        for (const s of scripts) {
+            const p = path.join(t.hooksBuild, s);
+            const mode = fs.statSync(p).mode;
+            const exec = (mode & 0o111) !== 0;
+            if (!exec)
+                nonExec++;
+            console.log(`  ${exec ? '✓' : '✗'} ${s}`);
+        }
+        if (nonExec > 0)
+            console.log(`  ⚠ ${nonExec} hook(s) sin bit ejecutable — corre \`trycore-build init --copy\` o \`chmod +x\``);
+    }
+    else {
+        console.log('  — sin hooks instalados (corre `trycore-build init`)');
+    }
+    // Detección de doble canal (CLI settings.json + plugin) [H3]
+    const settingsHasHooks = fs.existsSync(t.settingsFile) &&
+        /hooks\/build\//.test(fs.readFileSync(t.settingsFile, 'utf8'));
+    if (settingsHasHooks) {
+        console.log('');
+        console.log('ℹ Hooks del arnés detectados en settings.json (canal CLI).');
+        console.log('  Si además instalaste el plugin nativo, la cadena de comando es idéntica:');
+        console.log('  Claude Code deduplica y el hook dispara UNA vez. No requiere acción.');
+    }
+    console.log('═══════════════════════════════════════');
+    if (dep.missingHard.length > 0) {
+        console.error(`\n✗ Faltan requisitos duros: ${dep.missingHard.join(', ')}. Instálalos antes de operar el arnés.`);
+        process.exit(1);
+    }
+    console.log('\n✓ Requisitos satisfechos.');
+}

package/dist/commands/init.js

@@ -0,0 +1,129 @@
+// commands/init.ts — instala el build harness en el proyecto consumidor.
+// Idempotente: re-correr es seguro. Respeta .claude/, CLAUDE.md y el estado vivo preexistentes.
+//
+// Capa CLI del onboarding [H5,H7,H8]: siembra archivos + captura el stack MECÁNICO.
+// La parametrización SEMÁNTICA (PII, capa IA, capa determinista) y la auto-memory las
+// hace el slash command /build:onboard (Claude), NO este binario.
+import fs from 'node:fs';
+import path from 'node:path';
+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 } from '../lib/state-seed.js';
+import { mergeHarnessSettings } from '../lib/settings-merge.js';
+import { captureStack, renderAllowlist } from '../lib/stack-prompt.js';
+import { checkDeps } from './doctor.js';
+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';
+export async function init(opts) {
+    const targetDir = path.resolve(opts.targetDir);
+    if (!fs.existsSync(targetDir))
+        throw new Error(`Directorio no existe: ${targetDir}`);
+    const version = readPackageVersion();
+    const linkMode = opts.useCopy ? 'copy' : 'symlink';
+    const t = targetPaths(targetDir);
+    let mode = opts.mode ?? 'auto';
+    if (mode === 'auto')
+        mode = fs.existsSync(t.versionFile) ? 'update' : 'init';
+    console.log(`▶ trycore-build ${mode}: ${targetDir}  (v${version}, ${linkMode})`);
+    // 0) Requisitos externos duros [C2,H4]
+    if (!opts.skipDoctor) {
+        const dep = checkDeps();
+        if (dep.missingHard.length > 0) {
+            console.error(`\n✗ Faltan requisitos externos: ${dep.missingHard.join(', ')}.`);
+            console.error('  openspec: npm i -g @fission-ai/openspec   |   python3 y git: vía tu gestor del sistema.');
+            console.error('  Instálalos y reintenta, o usa --skip-doctor para forzar (los hooks/openspec fallarán en runtime).');
+            process.exit(1);
+        }
+    }
+    // 1) Assets en rutas NATIVAS del harness
+    linkChildren(ASSETS.agentsBuild, t.agentsBuild, linkMode, (n) => n.endsWith('.md'));
+    linkChildren(ASSETS.commandsOpsx, t.commandsOpsx, linkMode, (n) => n.endsWith('.md'));
+    linkChildren(ASSETS.commandsBuild, t.commandsBuild, linkMode, (n) => n.endsWith('.md'));
+    const nSkills = linkChildren(ASSETS.skills, t.skillsDir, linkMode);
+    linkChildren(ASSETS.hooksBuild, t.hooksBuild, linkMode, (n) => n.endsWith('.sh'));
+    if (linkMode === 'copy')
+        chmodExec(t.hooksBuild); // preserva +x [H1]
+    // 2) Estado (schema/README versionados; build-state.json vacío solo si falta) [C1]
+    const { stateSeeded } = seedState(targetDir);
+    // 3) stack-allowlist.json del consumidor (artefacto del consumidor)
+    let allowlist = null;
+    if (!fs.existsSync(t.configFile) && mode === 'init') {
+        const { cfg, interactive } = await captureStack(opts.stackFlags ?? {});
+        allowlist = renderAllowlist(cfg);
+        if (!interactive) {
+            console.log('  ℹ stack capturado de flags/defaults (no interactivo). Ajusta .claude/config/stack-allowlist.json o corre /build:onboard.');
+        }
+    }
+    const { configSeeded } = seedConfig(targetDir, allowlist);
+    // 4) Hooks + permisos mínimos en settings.json (canal CLI) [H3,H11]
+    const { addedHooks, addedPerms } = mergeHarnessSettings(t.settingsFile);
+    // 5) CLAUDE.md: bloque marcado con {{placeholders}} SIN resolver (los resuelve /build:onboard)
+    syncClaudeMdBlock(targetDir, version);
+    // 6) .gitignore: lista los assets symlinkeados + estado vivo [H1]
+    syncGitignoreBlock(targetDir, linkMode);
+    // 7) marca de versión
+    fs.writeFileSync(t.versionFile, version + '\n', 'utf8');
+    // 8) Resumen
+    console.log('');
+    console.log(`✓ Build harness instalado en ${targetDir}`);
+    console.log(`  Agentes:   ${countChildren(t.agentsBuild)} en .claude/agents/build/`);
+    console.log(`  Comandos:  ${countChildren(t.commandsOpsx)} /opsx:* + ${countChildren(t.commandsBuild)} /build:*`);
+    console.log(`  Skills:    ${nSkills} en .claude/skills/`);
+    console.log(`  Hooks:     ${countChildren(t.hooksBuild)} en .claude/hooks/build/ (settings.json +${addedHooks} hook(s), +${addedPerms} permiso(s))`);
+    console.log(`  Estado:    ${stateSeeded ? 'build-state.json sembrado (vacío)' : 'build-state.json preservado'}`);
+    console.log(`  Config:    ${configSeeded ? 'stack-allowlist.json sembrado' : 'stack-allowlist.json preservado'}`);
+    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');
+}
+function syncClaudeMdBlock(targetDir, version) {
+    const t = targetPaths(targetDir);
+    if (!fs.existsSync(ASSETS.templateClaudeMd)) {
+        throw new Error(`Plantilla no encontrada: ${ASSETS.templateClaudeMd}`);
+    }
+    const template = fs
+        .readFileSync(ASSETS.templateClaudeMd, 'utf8')
+        .replace(/\{\{BUILD_HARNESS_VERSION\}\}/g, version);
+    const lines = template.split('\n');
+    const b = lines.findIndex((l) => l.includes(BEGIN));
+    const e = lines.findIndex((l) => l.includes(END));
+    if (b === -1 || e === -1)
+        throw new Error('CLAUDE.md.template sin markers BEGIN/END trycore-build-harness');
+    const blockContent = lines.slice(b, e + 1).join('\n');
+    if (!fs.existsSync(t.claudeMd)) {
+        fs.writeFileSync(t.claudeMd, template, 'utf8');
+        console.log('  ✓ CLAUDE.md creado desde template');
+    }
+    else {
+        const action = upsertMarkedBlock({ beginMarker: BEGIN, endMarker: END, blockContent, filePath: t.claudeMd });
+        console.log(`  ✓ Bloque trycore-build-harness ${action === 'replaced' ? 'actualizado' : 'anexado'} en CLAUDE.md`);
+    }
+}
+function syncGitignoreBlock(targetDir, mode) {
+    const t = targetPaths(targetDir);
+    const isGitRepo = fs.existsSync(path.join(targetDir, '.git'));
+    if (!isGitRepo && !fs.existsSync(t.gitignore))
+        return;
+    const lines = [GI_BEGIN + ' ───────────────────────', '.claude/state/build-state.json'];
+    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/');
+        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)
+            lines.push(`.claude/skills/${s}/`);
+        lines.push('.claude/.build-harness-version');
+    }
+    lines.push(GI_END + ' ──────────────────────');
+    upsertMarkedBlock({
+        beginMarker: GI_BEGIN,
+        endMarker: GI_END,
+        blockContent: lines.join('\n'),
+        filePath: t.gitignore,
+    });
+    console.log('  ✓ .gitignore actualizado');
+}