LibroOS

Nombre del producto: LIBROOS

De codex (el formato que reemplazó al rollo y definió el libro moderno) + el sufijo tecnológico -a que evoca sistema, motor y automatización. Un nombre corto, pronunciable en todos los mercados, con dominio de marca defendible y gravedad editorial.

Sistema de marca

PRD — Visión, problema y oportunidad

LibroOS es el sistema operativo de publicación independiente: un espacio donde estrategia, escritura, diseño, cumplimiento técnico y exportación dejan de ser 6 herramientas desconectadas y se convierten en un solo flujo orquestado por IA.

Visión

Que cualquier persona con una idea publique con la calidad de una editorial profesional. LibroOS comprime el ciclo idea→publicación de semanas a horas, sin sacrificar dirección de arte, tipografía editorial ni cumplimiento técnico de KDP (Kindle eBook, tapa blanda y tapa dura).

Problema

Oportunidad

Usuarios y Jobs-to-be-Done

Features por prioridad

Tipos de libro soportados

Los 8 módulos core

Cada módulo es un producto en sí mismo, con superficie propia en la UI, agentes asignados y contratos de datos claros. Juntos forman el pipeline idea → paquete KDP.

Pipeline de producción (estado por proyecto)

Arquitectura multiagente orquestada

Un orquestador (Hermes) con memoria operativa de proyecto dirige a 4 modelos base y 10 subagentes especializados a través de un protocolo de tareas tipado. Ningún agente escribe directamente en el proyecto: todo pasa por contratos de entrada/salida validados.

Ficha técnica de cada subagente

Protocolo de comunicación entre agentes

// Todo trabajo circula como TaskEnvelope tipado (JSON) por la cola
TaskEnvelope {
  task_id:        uuid
  project_id:     uuid
  agent:          "cover_art_director"
  intent:         "generate_cover_variants"
  inputs:         { brief_ref, style_tokens_ref, trim, page_count }
  constraints:    { max_variants: 6, budget_tokens: 40000, deadline_ms: 90000 }
  depends_on:     [task_id...]          // grafo DAG de dependencias
  quality_gate:   "art_director_review"  // validador que debe aprobar el output
  fallback:       { retry: 2, then: "downgrade_model", finally: "human_review" }
  trace:          { parent_task, cost_usd, model_used, latency_ms }
}

Jerarquía y lógica de fallback

Flujo de generación visual (portadas e ilustraciones)

Arquitectura del sistema

Arquitectura de servicios modular, event-driven, con separación estricta entre plano de aplicación (CRUD, colaboración) y plano de generación (agentes, render). Todo lo pesado ocurre en workers asíncronos con colas.

Flujo de datos: "Generar capítulo 4"

Motor de render y export

// Cálculo de cubierta print (lógica calculadora KDP integrada)
function computePrintCover(trim, pages, paper, binding) {
  const spine = pages * PAPER_FACTOR[paper]        // ej. cream: 0.0025" / página
  const bleed = 0.125                              // pulgadas por lado
  const wrap  = binding === "hardcover" ? HC_WRAP : 0
  return {
    fullWidth:  bleed + wrap + trim.w + spine + trim.w + wrap + bleed,
    fullHeight: bleed + wrap + trim.h + wrap + bleed,
    spineTextAllowed: pages >= 79,                   // regla KDP
    barcodeZone: { w: 2.0, h: 1.2, corner: "back-bottom-right" }
  }
}

Modelo de datos

PostgreSQL como fuente de verdad, con versionado inmutable de contenido (cada guardado crea una revisión), assets en object storage referenciados por hash, y trazabilidad completa de cada output de IA hasta su prompt y su costo.

-- Núcleo de identidad y colaboración
users        (id, email, name, locale, plan, created_at)
workspaces   (id, name, plan, branding_json, owner_id)
memberships  (workspace_id, user_id, role: owner|editor|designer|reviewer|viewer)

-- Proyectos y pipeline
projects     (id, workspace_id, title, book_type, trim_size, binding[],
              status: strategy|manuscript|layout|cover|metadata|preflight|export|published,
              kdp_spec_snapshot_id, style_tokens_json, created_by)
book_briefs  (id, project_id, niche, audience, value_prop, angle,
              market_analysis_json, approved_at, version)

-- Manuscrito: bloques semánticos versionados
manuscripts  (id, project_id, language, current_revision_id)
chapters     (id, manuscript_id, position, title, status)
blocks       (id, chapter_id, position, type: heading|para|image|table|activity|page_break,
              content_json, style_ref)
revisions    (id, manuscript_id, parent_revision_id, author_type: user|agent,
              agent_task_id, diff_json, created_at)   -- historial inmutable
story_bible  (id, project_id, entity_type: character|place|term|rule,
              name, facts_json, embeddings vector)     -- memoria de coherencia

-- Diseño
layouts      (id, project_id, template_id, typography_json, margins_json,
              bleed bool, page_count_estimated, page_count_final)
covers       (id, project_id, kind: ebook|paperback|hardcover, status,
              art_asset_id, typography_layer_json, spine_width_mm, variant_group)
cover_variants (id, cover_id, asset_id, ai_score_json, user_rating, selected bool)

-- Metadata comercial
book_metadata (id, project_id, title, subtitle, description_html,
               keywords text[7], categories text[3], bullets_json, version, ab_group)

-- IA: trazabilidad total
agent_tasks  (id, project_id, agent, intent, status, depends_on uuid[],
              inputs_json, outputs_json, model_used, tokens_in, tokens_out,
              cost_usd, latency_ms, quality_gate_result, retries)
prompts      (id, agent, intent, version, template_text, active bool)  -- registry versionado
project_memory (id, project_id, kind: fact|decision|feedback,
                content, embeddings vector, source_task_id)

-- Assets y export
assets       (id, project_id, kind: image|font|svg|pdf|epub|docx|zip,
              storage_key, sha256, width, height, dpi, bytes, license)
export_jobs  (id, project_id, formats text[], status: queued|rendering|validating|done|failed,
              compliance_report_id, package_asset_id, manifest_json, created_by)
compliance_reports (id, project_id, spec_snapshot_id, checks_json,
                    result: pass|warn|fail, waivers_json, created_at)
kdp_spec_snapshots (id, version_label, trim_sizes_json, margin_rules_json,
                    paper_factors_json, cover_rules_json, published_at)

-- Colaboración
comments     (id, project_id, anchor_type: block|cover|page|metadata,
              anchor_id, body, author_id, resolved_at)
approvals    (id, project_id, stage, approver_id, decision, note, created_at)

Relaciones clave

Experiencia y diseño: lujo editorial

Referencia visual: la precisión de Linear, la calma de Notion, el canvas de Figma y la gravedad tipográfica de una casa editorial centenaria. Minimalismo premium: pocas cosas en pantalla, todas perfectas.

Concepto visual — "Ink & Brass"

Sitemap

libroos.app
├── /library                    ← Dashboard: biblioteca de proyectos, estados, actividad
├── /new                        ← Wizard de creación (tipo de libro → trim → objetivo)
├── /project/:id
│   ├── /strategy               ← AI Book Strategist · Book Brief
│   ├── /manuscript             ← Studio de escritura (outline + editor + copiloto)
│   ├── /layout                 ← Layout Engine (preview WYSIWYG de impresión)
│   ├── /cover                  ← Cover Studio (variantes, tipografía, print wrap)
│   ├── /metadata               ← Metadata Intelligence
│   ├── /preflight              ← Compliance Engine (checklist técnico)
│   ├── /export                 ← Export Center (formatos + paquete KDP)
│   └── /history                ← Versiones, comentarios, aprobaciones
├── /assets                     ← Biblioteca de assets del workspace
├── /templates                  ← Plantillas editoriales premium
└── /settings                   ← Workspace, equipo, facturación, API

Flujo de usuario maestro (12 pasos)

Pantallas clave (wireframes de alta intención)

① Library — el estudio del autor

Cada proyecto es una tarjeta-libro con su portada real como identidad, anillo de progreso por etapa del pipeline y pulso violeta si hay agentes trabajando en vivo. Command bar ⌘K global para saltar a cualquier proyecto o acción.

② Manuscript Studio — escribir con un equipo editorial al lado

Editor sin distracciones al centro; outline navegable a la izquierda; a la derecha el copiloto contextual con avisos de coherencia (la biblia narrativa detecta contradicciones), medidor de voz y metas. Toda acción de IA es una selección + intención: nunca formularios.

③ Cover Studio — mesa de dirección de arte

Grid de variantes con score del Art Director y test de legibilidad en thumbnail (así se ve en la tienda). Conmutador eBook ↔ cubierta print completa: al pasar a print, aparecen lomo con medida exacta en vivo, contraportada y zona de barcode bloqueada.

④ Preflight — compliance como experiencia de calma

Cada check explica qué regla de KDP aplica y por qué, muestra el punto exacto en el documento y ofrece corrección en un clic. El export queda bloqueado hasta verde total o waiver firmado.

Design system — componentes

Roadmap de desarrollo

Cuatro fases con criterio de salida claro. El MVP ya publica un libro real en KDP de punta a punta — no una demo.

KPIs de producto

Diferenciadores competitivos

El flujo actual del autor independiente está fragmentado entre Kindle Create (manuscrito), Cover Creator (portada básica), la calculadora de cubierta, Word/Canva y hojas de keywords. LibroOS no compite con cada pieza: elimina la fragmentación.

Fosos defensivos

Stack final recomendado

Criterio: velocidad de iteración de producto, render determinista para print, colas robustas para IA, y un solo lenguaje (TypeScript) en toda la superficie para maximizar densidad de talento.

Lógica de integración de los 5 sistemas de IA

Estructura modular del código (monorepo)

libroos/
├── apps/
│   ├── web/                    ← Next.js: UI completa, editores, canvas
│   └── api/                    ← NestJS: gateway, dominios, auth, billing
├── services/
│   ├── hermes/                 ← Orquestador: DAG, memoria, gates, presupuestos
│   ├── render/                 ← Workers: Chromium→PDF, EPUB builder, mockups
│   ├── preflight/              ← Compliance engine: parser PDF, DPI, fuentes, lomo
│   └── procedural/             ← Generadores: sudokus, sopas, planners, mazes
├── packages/
│   ├── ui/                     ← Design system "Ink & Brass" (tokens + componentes)
│   ├── agents/                 ← Definiciones de agentes, prompts versionados, tools
│   ├── kdp-specs/              ← Snapshots de specs KDP + calculadora de cubierta
│   ├── book-schema/            ← Schema de bloques del manuscrito (fuente de verdad)
│   ├── templates/              ← Plantillas editoriales (interior + portada) themables
│   └── shared/                 ← Tipos, validadores zod, clientes API
└── infra/                      ← IaC, K8s, CI/CD, seeds

Por qué LibroOS gana

LibroOS no es una herramienta de IA que hace libros. Es una casa editorial completa, comprimida en software, que trabaja para cada autor.