sylo-fieldbrain 0.1.0

package/scripts/models.py

@@ -0,0 +1,355 @@
+"""SQLAlchemy models for sylo-logicscout shared Postgres data.
+
+Auth, chat, and batch L5X analysis job tables are intentionally omitted.
+Sylo SQLite owns chats; LogicForge owns L5X parse tooling.
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    LargeBinary,
+    String,
+    Text,
+    UniqueConstraint,
+    func,
+    text as sql_text,
+)
+from sqlalchemy.dialects.postgresql import TSVECTOR
+from sqlalchemy.orm import declarative_base
+
+Base = declarative_base()
+
+DEFAULT_OLLAMA_ENDPOINT = "http://localhost:11434"
+
+
+class Project(Base):
+    """Project metadata (L5X path/hash point at LogicForge-managed files)."""
+
+    __tablename__ = "projects"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(255), nullable=False, index=True)
+    controller_name = Column(String(255), nullable=True)
+    processor_type = Column(String(100), nullable=True)
+    software_revision = Column(String(50), nullable=True)
+    l5x_file_path = Column(String(500), nullable=True)
+    l5x_file_hash = Column(String(64), nullable=True, index=True)
+    plc_ip = Column(String(45), nullable=True)
+    plc_read_enabled = Column(Boolean, default=False, nullable=False)
+    max_alert_chats = Column(Integer, nullable=False, default=10)
+    hmi_embed_token = Column(String(255), nullable=True)
+    cross_project_share = Column(String(20), nullable=False, default="share")
+    cross_project_search = Column(Boolean, nullable=False, default=True)
+    org_id = Column(String(100), nullable=False, default="default", index=True)
+    project_tags_json = Column(Text, nullable=True)
+    domain = Column(String(100), nullable=True)
+    controller_family = Column(String(100), nullable=True)
+    reminders_muted = Column(Boolean, nullable=False, default=False)
+    is_system_hidden = Column(Boolean, nullable=False, default=False, server_default="false")
+    job_number = Column(String(20), nullable=True, index=True)
+    parent_project_id = Column(Integer, ForeignKey("projects.id", ondelete="SET NULL"), nullable=True, index=True)
+    l5x_status = Column(String(20), nullable=False, default="analyzed")
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class Document(Base):
+    """Uploaded document metadata; ingestion pipeline fills analysis rows later."""
+
+    __tablename__ = "documents"
+
+    id = Column(Integer, primary_key=True, index=True)
+    scope = Column(String(20), nullable=False, default="project_local", index=True)
+    owner_project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=True, index=True)
+    title = Column(String(255), nullable=False)
+    original_filename = Column(String(255), nullable=False)
+    stored_path = Column(String(500), nullable=False)
+    file_hash = Column(String(64), nullable=False, index=True)
+    mime_type = Column(String(100), nullable=True)
+    file_size = Column(Integer, nullable=True)
+    category = Column(String(20), nullable=False, default="other", index=True)
+    tags_json = Column(Text, nullable=True)
+    manufacturer = Column(String(100), nullable=True)
+    model = Column(String(100), nullable=True)
+    version = Column(String(50), nullable=True)
+    archived = Column(Boolean, nullable=False, default=False)
+    file_content = Column(LargeBinary, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+
+    __table_args__ = (UniqueConstraint("file_hash", name="uq_documents_file_hash"),)
+
+
+class ProjectDocumentLink(Base):
+    """Attach a document to a project."""
+
+    __tablename__ = "project_document_links"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    document_id = Column(Integer, ForeignKey("documents.id", ondelete="CASCADE"), nullable=False, index=True)
+    role = Column(String(20), nullable=False, default="reference", index=True)
+    attached_at = Column(DateTime, default=func.now())
+
+    __table_args__ = (UniqueConstraint("project_id", "document_id", name="uq_project_document_link"),)
+
+
+class GlobalSettings(Base):
+    """Server-wide settings singleton."""
+
+    __tablename__ = "global_settings"
+
+    id = Column(Integer, primary_key=True, index=True)
+    ollama_endpoint = Column(String(500), nullable=True, default=DEFAULT_OLLAMA_ENDPOINT)
+    llm_model = Column(String(100), nullable=True)
+    summarizer_model = Column(String(100), nullable=True)
+    vision_model = Column(String(100), nullable=True)
+    doc_vision_model = Column(String(100), nullable=True)
+    analysis_model = Column(String(100), nullable=True)
+    embedding_model = Column(String(100), nullable=True)
+    search_index_schema_version = Column(Integer, nullable=False, default=1, server_default="1")
+    search_query_expansion = Column(Boolean, nullable=False, default=True)
+    search_reranking_enabled = Column(Boolean, nullable=False, default=True)
+    search_rerank_pool = Column(Integer, nullable=False, default=15)
+    search_context_window = Column(Integer, nullable=False, default=1)
+    search_rerank_backend = Column(String(20), nullable=False, default="ollama")
+    search_rerank_model = Column(String(100), nullable=True)
+    ollama_num_ctx = Column(Integer, nullable=True)
+    ollama_num_ctx_agents_json = Column(Text, nullable=True)
+    ollama_profiles_json = Column(Text, nullable=True)
+    ollama_agent_endpoints_json = Column(Text, nullable=True)
+    marker_pdf_enabled = Column(Boolean, nullable=False, default=True, server_default="true")
+    marker_pdf_use_llm = Column(Boolean, nullable=False, default=False, server_default="false")
+    marker_pdf_ollama_model = Column(String(100), nullable=True)
+    vision_render_dpi = Column(Integer, nullable=False, default=200, server_default="200")
+    max_inflight_vision = Column(Integer, nullable=False, default=1, server_default="1")
+    max_inflight_text = Column(Integer, nullable=False, default=1, server_default="1")
+    l5x_analysis_concurrency = Column(Integer, nullable=False, default=1, server_default="1")
+    vision_timeout_seconds = Column(Integer, nullable=False, default=300, server_default="300")
+    text_timeout_seconds = Column(Integer, nullable=False, default=180, server_default="180")
+    find_logic_llm_model = Column(String(100), nullable=True)
+    documentation_search_llm_model = Column(String(100), nullable=True)
+    orchestrator_temperature = Column(Float, nullable=True)
+    summarizer_temperature = Column(Float, nullable=True)
+    summarizer_max_summary_chars = Column(Integer, nullable=True)
+    vision_temperature = Column(Float, nullable=True)
+    doc_vision_temperature = Column(Float, nullable=True)
+    analysis_temperature = Column(Float, nullable=True)
+    documentation_search_temperature = Column(Float, nullable=True)
+    find_logic_temperature = Column(Float, nullable=True)
+    search_rerank_temperature = Column(Float, nullable=True)
+    orchestrator_max_iterations = Column(Integer, nullable=True)
+    find_logic_default_max_iterations = Column(Integer, nullable=True)
+    documentation_search_default_max_iterations = Column(Integer, nullable=True)
+    find_logic_effort_low_max_iterations = Column(Integer, nullable=True)
+    find_logic_effort_medium_max_iterations = Column(Integer, nullable=True)
+    find_logic_effort_high_max_iterations = Column(Integer, nullable=True)
+    find_logic_system_prompt_extra = Column(Text, nullable=True)
+    find_logic_inner_user_message = Column(Text, nullable=True)
+    find_logic_allowed_tools_json = Column(Text, nullable=True)
+    ollama_warmup_on_start = Column(Boolean, nullable=False, default=False, server_default=sql_text("false"))
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class DocumentAnalysis(Base):
+    """LLM-generated analysis for an uploaded document."""
+
+    __tablename__ = "document_analyses"
+
+    id = Column(Integer, primary_key=True, index=True)
+    document_id = Column(Integer, ForeignKey("documents.id", ondelete="CASCADE"), nullable=False, unique=True, index=True)
+    llm_index_description = Column(Text, nullable=False)
+    parsed_text_with_images = Column(Text, nullable=True)
+    analyzed_at = Column(DateTime, default=func.now())
+
+
+class DocumentPageImage(Base):
+    """Vision-model description for a document page containing images or diagrams."""
+
+    __tablename__ = "document_page_images"
+
+    id = Column(Integer, primary_key=True, index=True)
+    document_id = Column(Integer, ForeignKey("documents.id", ondelete="CASCADE"), nullable=False, index=True)
+    page_number = Column(Integer, nullable=False)
+    has_images = Column(Boolean, default=True, nullable=False)
+    llm_image_description = Column(Text, nullable=True)
+    llm_page_detail = Column(Text, nullable=True)
+    ocr_text = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+
+
+class DocumentPdfOutline(Base):
+    """Per-document TOC entries (physical_pdf_page is 0-based)."""
+
+    __tablename__ = "document_pdf_outline"
+
+    id = Column(Integer, primary_key=True, index=True)
+    document_id = Column(Integer, ForeignKey("documents.id", ondelete="CASCADE"), nullable=False, index=True)
+    level = Column(Integer, nullable=False)
+    title = Column(Text, nullable=False)
+    toc_page_claimed = Column(Integer, nullable=True)
+    physical_pdf_page = Column(Integer, nullable=False)
+    verification = Column(String(32), nullable=False)
+    sequence = Column(Integer, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+
+
+class Alert(Base):
+    """Tag-monitoring alert definition."""
+
+    __tablename__ = "alerts"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    tag_name = Column(String(255), nullable=False)
+    trigger_value_type = Column(String(20), nullable=False)
+    trigger_operator = Column(String(20), nullable=False, default="eq")
+    trigger_value = Column(Text, nullable=False)
+    command = Column(Text, nullable=False)
+    enabled = Column(Boolean, default=True, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class AlertResponse(Base):
+    """Agent response to a triggered alert."""
+
+    __tablename__ = "alert_responses"
+
+    id = Column(Integer, primary_key=True, index=True)
+    alert_id = Column(Integer, ForeignKey("alerts.id", ondelete="CASCADE"), nullable=False, index=True)
+    tag_value = Column(Text, nullable=True)
+    agent_response = Column(Text, nullable=False, default="")
+    is_processing = Column(Boolean, default=False, nullable=False)
+    triggered_at = Column(DateTime, default=func.now())
+    responded_at = Column(DateTime, nullable=True)
+
+
+class TagTroubleshootingSolution(Base):
+    """Human-approved resolution for a project tag."""
+
+    __tablename__ = "tag_troubleshooting_solutions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    tag_name = Column(String(255), nullable=False, index=True)
+    solution_text = Column(Text, nullable=False)
+    source_ref = Column(String(255), nullable=True)
+    logged_by = Column(String(100), nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+    __table_args__ = (Index("ix_tag_trouble_solutions_project_tag", "project_id", "tag_name"),)
+
+
+class BrainDraft(Base):
+    """Brain change audit record."""
+
+    __tablename__ = "brain_drafts"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    source_ref = Column(String(255), nullable=True)
+    status = Column(String(20), nullable=False, default="pending")
+    op = Column(String(50), nullable=False)
+    target_path = Column(String(500), nullable=False)
+    payload_json = Column(Text, nullable=False)
+    content_hash_before = Column(String(64), nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    expires_at = Column(DateTime, nullable=True)
+    applied_at = Column(DateTime, nullable=True)
+
+
+class MaintenanceLogEntry(Base):
+    """Shop maintenance log entry (retrieval-first)."""
+
+    __tablename__ = "maintenance_log_entries"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="SET NULL"), nullable=True, index=True)
+    title = Column(String(255), nullable=False)
+    body = Column(Text, nullable=False)
+    fault_code = Column(String(100), nullable=True, index=True)
+    equipment_tag = Column(String(255), nullable=True, index=True)
+    logged_by = Column(String(100), nullable=True)
+    deleted_at = Column(DateTime, nullable=True, index=True)
+    created_at = Column(DateTime, default=func.now(), index=True)
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    search_vector = Column(TSVECTOR, nullable=True)
+
+
+class MaintenanceLogRevision(Base):
+    """Prior version of a maintenance log entry."""
+
+    __tablename__ = "maintenance_log_revisions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    log_entry_id = Column(
+        Integer, ForeignKey("maintenance_log_entries.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    title = Column(String(255), nullable=False)
+    body = Column(Text, nullable=False)
+    fault_code = Column(String(100), nullable=True)
+    equipment_tag = Column(String(255), nullable=True)
+    logged_by = Column(String(100), nullable=True)
+    revision_number = Column(Integer, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+
+
+class BrainDocument(Base):
+    """Brain markdown stored in Postgres (canonical; local disk is optional cache)."""
+
+    __tablename__ = "brain_documents"
+
+    id = Column(Integer, primary_key=True, index=True)
+    scope = Column(String(20), nullable=False, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=True, index=True)
+    relative_path = Column(String(500), nullable=False)
+    content = Column(Text, nullable=False, default="")
+    deleted_at = Column(DateTime, nullable=True, index=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+
+
+class BrainDocumentRevision(Base):
+    """Prior version of a brain document."""
+
+    __tablename__ = "brain_document_revisions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    brain_document_id = Column(
+        Integer, ForeignKey("brain_documents.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    relative_path = Column(String(500), nullable=False)
+    content = Column(Text, nullable=False)
+    revision_number = Column(Integer, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+
+
+class SearchIndex(Base):
+    """Hybrid search projection (tsvector + optional pgvector embedding).
+
+    The ``embedding`` column is ``vector(768)`` when pgvector is installed;
+    created in migration 002, not mapped here.
+    """
+
+    __tablename__ = "search_index"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id", ondelete="CASCADE"), nullable=False, index=True)
+    source_type = Column(String(50), nullable=False, index=True)
+    source_id = Column(String(500), nullable=True)
+    label = Column(String(500), nullable=True)
+    path = Column(String(500), nullable=True)
+    content = Column(Text, nullable=True)
+    chunk_index = Column(Integer, default=0)
+    section_id = Column(Integer, nullable=False, default=0)
+    entry_share = Column(String(20), nullable=False, default="project_only")
+    brain_type = Column(String(50), nullable=True)
+    brain_status = Column(String(50), nullable=True)

package/scripts/pgvector_enable.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""Enable pgvector in the FieldBrain database and ensure embedding schema."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import urllib.parse
+
+from sqlalchemy import create_engine, text
+
+from _db_lib import SCHEMA_VERSION, check_pgvector, load_database_config, run_health_check
+from _json_out import emit, emit_error
+from services.pgvector_windows import layman_pgvector_steps, windows_install_status
+
+
+def _build_admin_url(host: str, port: int, database: str, user: str, password: str) -> str:
+    return (
+        f"postgresql://{urllib.parse.quote(user)}:{urllib.parse.quote(password)}"
+        f"@{host}:{port}/{urllib.parse.quote(database)}"
+    )
+
+
+def _try_create_extension(app_url: str) -> tuple[bool, str | None]:
+    engine = create_engine(app_url, isolation_level="AUTOCOMMIT", pool_pre_ping=True)
+    try:
+        with engine.connect() as conn:
+            conn.execute(text("CREATE EXTENSION IF NOT EXISTS vector"))
+        with engine.connect() as conn:
+            row = conn.execute(
+                text("SELECT extversion FROM pg_extension WHERE extname = 'vector'")
+            ).fetchone()
+        if row:
+            return True, str(row[0])
+        return False, "CREATE EXTENSION ran but vector extension not visible"
+    except Exception as exc:
+        return False, str(exc)
+    finally:
+        engine.dispose()
+
+
+def _ensure_embedding_schema(app_url: str) -> tuple[bool, str | None]:
+    engine = create_engine(app_url, isolation_level="AUTOCOMMIT", pool_pre_ping=True)
+    try:
+        with engine.connect() as conn:
+            pg_ok = conn.execute(
+                text("SELECT 1 FROM pg_extension WHERE extname = 'vector'")
+            ).fetchone()
+            if not pg_ok:
+                return False, "pgvector extension not enabled in this database"
+            conn.execute(
+                text("ALTER TABLE search_index ADD COLUMN IF NOT EXISTS embedding vector(768)")
+            )
+            conn.execute(
+                text(
+                    """
+                    CREATE INDEX IF NOT EXISTS idx_search_index_embedding
+                    ON search_index USING hnsw (embedding vector_cosine_ops)
+                    """
+                )
+            )
+        return True, None
+    except Exception as exc:
+        return False, str(exc)
+    finally:
+        engine.dispose()
+
+
+def _run_migrate(app_url: str) -> tuple[int | None, str | None]:
+    from alembic import command
+
+    from _db_lib import read_applied_schema_version, reset_engine
+    from db_migrate import alembic_config
+
+    os.environ["SYLO_FIELDBRAIN_DATABASE_URL"] = app_url
+    reset_engine()
+    try:
+        command.upgrade(alembic_config(), "head")
+    except Exception as exc:
+        return None, str(exc)
+    reset_engine()
+    try:
+        applied = read_applied_schema_version()
+    except Exception as exc:
+        return None, f"Migration ran but schema version unreadable: {exc}"
+    if applied != SCHEMA_VERSION:
+        return applied, f"Expected schema {SCHEMA_VERSION}, got {applied}"
+    return applied, None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--admin-user", default="postgres")
+    parser.add_argument("--admin-password", default="")
+    parser.add_argument("--host", default="")
+    parser.add_argument("--port", type=int, default=0)
+    parser.add_argument("--database", default="")
+    args = parser.parse_args()
+
+    admin_password = (args.admin_password or os.environ.get("SYLO_FIELDBRAIN_BOOTSTRAP_ADMIN_PASSWORD") or "").strip()
+    if not admin_password:
+        emit_error("Postgres superuser password is required (not saved).")
+
+    cfg = load_database_config() or {}
+    host = (args.host or str(cfg.get("host") or "localhost")).strip()
+    db_mode = "remote" if host not in ("localhost", "127.0.0.1") else "local"
+    port = args.port or int(cfg.get("port") or 5432)
+    database = (args.database or str(cfg.get("database") or "fieldbrain")).strip()
+    admin_user = (args.admin_user or "postgres").strip()
+
+    health = run_health_check()
+    if health.get("postgres_connected") is not True:
+        emit_error(health.get("postgres_error", "Connect to Postgres first (Test connection)."))
+
+    major = health.get("postgres_major")
+    if isinstance(major, str) and major.isdigit():
+        major = int(major)
+    install = windows_install_status(major if isinstance(major, int) else None)
+
+    admin_url = _build_admin_url(host, port, database, admin_user, admin_password)
+    ext_ok, ext_detail = _try_create_extension(admin_url)
+    if not ext_ok:
+        guide = layman_pgvector_steps(
+            major if isinstance(major, int) else None,
+            files_installed=bool(install.get("vector_files_installed")),
+            db_mode=db_mode,
+        )
+        emit_error(
+            f"Could not enable pgvector: {ext_detail}",
+            pgvector_setup=guide,
+            **install,
+        )
+
+    app_user = str(cfg.get("username") or "fieldbrain")
+    app_password = str(cfg.get("password") or "")
+    app_url = _build_admin_url(host, port, database, app_user, app_password)
+    schema_ok, schema_err = _ensure_embedding_schema(app_url)
+    if not schema_ok:
+        emit_error(f"pgvector enabled but schema update failed: {schema_err}", pgvector_detail=ext_detail)
+
+    applied, migrate_err = _run_migrate(app_url)
+    if migrate_err:
+        emit_error(migrate_err, pgvector_detail=ext_detail)
+
+    pg_ok, pg_ver = check_pgvector()
+    lines = [
+        f"Semantic search enabled (pgvector {ext_detail}).",
+        f"Schema version {applied}.",
+        "Superuser password was not saved.",
+        "Re-ingest documents later if you want embeddings on existing files.",
+    ]
+    emit(
+        {
+            "ok": True,
+            "operator_chat": "\n".join(lines),
+            "pgvector_ok": pg_ok,
+            "pgvector_detail": pg_ver,
+            "applied_schema_version": applied,
+            **install,
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/pgvector_guide.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Layman pgvector setup guide for FieldBrain."""
+
+from __future__ import annotations
+
+from _db_lib import load_database_config, run_health_check
+from _json_out import emit
+from services.pgvector_windows import layman_pgvector_steps, windows_install_status
+
+
+def main() -> None:
+    summary = run_health_check()
+    cfg = load_database_config() or {}
+    host = str(cfg.get("host") or "localhost").strip()
+    db_mode = "remote" if host not in ("localhost", "127.0.0.1") else "local"
+
+    major = summary.get("postgres_major")
+    if isinstance(major, str) and major.isdigit():
+        major = int(major)
+    install = windows_install_status(major if isinstance(major, int) else None)
+    pg_ok = summary.get("pgvector_available") is True
+    steps = layman_pgvector_steps(
+        major if isinstance(major, int) else None,
+        files_installed=bool(install.get("vector_files_installed")),
+        db_mode=db_mode,
+    )
+    if pg_ok:
+        steps = [
+            "pgvector is already enabled — semantic search is available when Ollama is running.",
+        ]
+    emit(
+        {
+            "ok": True,
+            "pgvector_ok": pg_ok,
+            "operator_chat": "\n".join(steps),
+            "pgvector_setup": steps,
+            **summary,
+            **install,
+        }
+    )
+
+
+if __name__ == "__main__":
+    main()

package/scripts/pgvector_install_files.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Install pgvector files from an operator-selected folder or zip."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+
+from _json_out import emit, emit_error
+from services.pgvector_windows import (
+    guess_pgroot_for_major,
+    install_pgvector_files,
+    resolve_source_dir,
+    windows_install_status,
+)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", required=True, help="Folder or .zip containing pgvector files")
+    parser.add_argument("--postgres-major", type=int, default=0)
+    parser.add_argument("--pgroot", default="", help="Override PostgreSQL install directory")
+    args = parser.parse_args()
+
+    major = args.postgres_major or int(os.environ.get("SYLO_FIELDBRAIN_POSTGRES_MAJOR") or 0) or None
+    pgroot_raw = (args.pgroot or os.environ.get("SYLO_FIELDBRAIN_PGROOT") or "").strip()
+    if pgroot_raw:
+        from pathlib import Path
+
+        pgroot = Path(pgroot_raw)
+    elif major:
+        pgroot = guess_pgroot_for_major(major)
+    else:
+        pgroot = None
+
+    if pgroot is None:
+        emit_error("Could not determine PostgreSQL install folder. Connect to Postgres and retry.")
+
+    source_dir, tmp, err = resolve_source_dir(args.source)
+    if err or source_dir is None:
+        emit_error(err or "Invalid source path")
+
+    try:
+        result = install_pgvector_files(source_dir, pgroot)
+    finally:
+        if tmp is not None:
+            tmp.cleanup()
+
+    status = windows_install_status(major)
+    payload = {**result, **status}
+    if result.get("ok"):
+        emit(
+            {
+                **payload,
+                "operator_chat": (
+                    f"Copied pgvector files into {result.get('pgroot')}.\n"
+                    "Next: Enable semantic search in FieldBrain Settings."
+                ),
+            }
+        )
+    emit_error(result.get("error", "Install failed"), **payload)
+
+
+if __name__ == "__main__":
+    main()