Official Portal: floworkos.com
Core Authority: Awengkaudico & TeguhFX (LV99 Super Admin)
Chief Architect & Sovereign Doctor: Dr. Flow
Territory Root: /opt/floworkos (Strict zero-drift Linux FHS territory; symlinked to user home)
Dual-Repository Architecture: Private Vault (backupflowork) & Sanitized Distribution (flowork-os) managed via builder/flowork-publisher.sh.

Flowork OS is an autonomous, privacy-hardened, GNU/Linux operating system where the host computer is fully ceded to the Flowork Sovereign AI Governor.

Unlike conventional desktop environments that treat AI as a disconnected chat widget or code assistant, Flowork OS fuses the Linux kernel, a dedicated Pure Rust window manager, direct hardware controllers, and the browser engine into a single intelligent canvas. Traditional legacy desktop environments (monolithic legacy desktops) are systematically replaced with the Flowork Canvas Shell, flowork-wm, and the Sovereign Agent Sidebar.

"Flowork is Linux. Linux applications are Flowork applications."
External Linux applications (Google Chrome, Blender, GIMP, VS Code, terminal emulators) run directly as dark sovereign windows or embedded nodes within the Flowork display canvas.

Flowork OS userland and daemons are compiled strictly into native Pure Rust binaries to achieve microsecond execution latency, absolute determinism, and minimal memory footprint:

┌────────────────────────────────────────────────────────────────────────┐
│                        FLOWORK SOVEREIGN OS                            │
├───────────────────────┬────────────────────────┬───────────────────────┤
│    bin/flowork-wm     │    bin/flowork-sysd    │      bin/x-flow       │
│  (Pure Rust WM / EWMH)│  (Pure Rust Systemd)   │  (Sovereign Core Host)│
│       515 KB          │        9.9 MB          │        5.8 MB         │
│     ~2.1 MB RAM       │      ~2.1 MB RAM       │       ~44 MB RAM      │
├───────────────────────┼────────────────────────┼───────────────────────┤
│ • X11 Map Interception│ • Native D-Bus (zbus)  │ • Multi-Domain Agent  │
│ • Auto-Dock Sidebar   │ • Native X11 (x11rb)   │ • Decoupled Disk JIT  │
│ • Modal Auth Raising  │ • Persistent CDP Pool  │ • Cloud Rotator       │
│ • Dynamic Auto-Tiling │ • Reflex Intent Engine │ • Canvas Web Host     │
│ • Global Hotkeys      │ • Axum REST (:18090)   │ • Axum REST (:19890)  │
└───────────────────────┴────────────────────────┴───────────────────────┘

• Footprint: Compiled binary size is ONLY 515 KILOBYTES, consuming ~2.1 MB RAM (vs legacy desktops >350MB).
• EWMH Compliance: Implements _NET_SUPPORTING_WM_CHECK, _NET_SUPPORTED, _NET_CLIENT_LIST, _NET_ACTIVE_WINDOW.
• Flowork Sidebar Dock: Automatically reserves a fixed strut on the right screen edge (width: 800px, full height).
• Modal Auth Raising: Automatically catches, centers, and raises authentication windows (Google Sign-In, Flowork Auth, Sovereign SSO).
• Dynamic Auto-Tiling:
  • 1 Window: Maximized across available canvas.
  • 2 Windows: Dynamic 50/50 side-by-side split.
  • 3+ Windows: Master & Stack split.
• Global Hotkeys: Super+A (toggle agent sidebar), Super+Return (launch terminal), Super+Q (close active window).

• Port: :18090 (Replaces legacy Node.js daemon; RAM reduced from ~60MB to 2.1MB).
• Native D-Bus (zbus): Controls PipeWire master volume, MPRIS2 media players, and desktop notifications via standard UNIX D-Bus sockets without spawning subprocesses.
• Native X11 Input (x11rb): Window focus, geometry shifts, and synthetic mouse/keyboard events via XTest without xdotool.
• Persistent Chrome CDP Pool (tokio-tungstenite): Pre-warmed WebSocket connection to Chrome CDP ports (9223, 9222), extracting interactive DOM elements in sub-5ms.
• Fast-Path Reflex Engine: Regex intent evaluation in < 10ms for volume, media, tabs, and system status queries.

• Port: :19890 (Flowork Autonomous Agent & Canvas Host).
• Decoupled Disk Architecture: Prompts reside in system/system_promp/promps/ and tool schemas reside in canvas-ui/tools/<tool_name>/manifest.json. Zero hardcoded prompts or JSON schemas in the .rodata binary section. All sovereign CLI utilities and executable tools reside in bin/ (the legacy root tools/ directory has been permanently removed and consolidated into bin/).
• Multi-Domain Governor Persona: Autonomous operating system stewardship covering Linux administration, browser flows, filesystem mutations, and visual applications.

• Sovereign Session Script: session/flowork-session.sh initializes flowork-wm, launches flowork-sysd, starts x-flow, applies dark sovereign themes, and docks the Flowork Sidebar.
• Session Registration: session/flowork.desktop installs into /usr/share/xsessions/flowork.desktop.
• Display Manager: LightDM (slick-greeter) boots directly into user-session=flowork.
• Sovereign Independence Invariant: No foreign panels, no monolithic compositors, no background bloat daemons, and zero GNOME applet bloat.

Flowork OS packages into an independent, bootable hybrid ISO (Flowork-OS-v1.0-x86_64.iso):

• Builder Script: builder/build-iso.sh (Automated 8-stage pipeline).
• Base System: Ubuntu 24.04 LTS (Noble Numbat minimal core).
• Package Manifest: builder/packages.list (Minimal X11, PipeWire audio, Linux kernel, Calamares installer; zero legacy desktop bloat).
• Filesystem: High-ratio XZ compressed Squashfs (filesystem.squashfs).
• Bootloader: Hybrid GRUB2 (UEFI + BIOS MBR via xorriso).

To compile the standalone ISO:

sudo bash /opt/floworkos/builder/build-iso.sh

/opt/floworkos/
├── ARCHITECTURE.md          # Exhaustive system architecture breakdown
├── README.md                # Project overview and baseline documentation
├── DEVELOPER.md             # Developer handbook, compilation & sovereign doctrines
│
├── core/                    # Flowork Sovereign Core Engine (Rust: axum, tokio, dynamic JIT)
│   ├── src/                 # Agent service, native tools, prompt seal, systemd runners
│   └── Cargo.toml           # Core Rust crate configuration
│
├── sysd/                    # Flowork System Daemon (Pure Rust: port 18090)
│   ├── src/                 # dbus_ctrl.rs, x11_ctrl.rs, cdp_pool.rs, reflex.rs, routes.rs
│   └── Cargo.toml           # System daemon Rust crate configuration
│
├── wm/                      # Flowork Sovereign Window Manager (Pure Rust: 515 KB)
│   ├── src/main.rs          # EWMH event loop, auto-tiling, sidebar dock, auth window centering
│   └── Cargo.toml           # Window manager Rust crate configuration
│
├── bin/                     # Sovereign binaries, executables & CLI tools (Consolidated; legacy tools/ removed)
│   ├── x-flow               # Compiled Core Engine binary (5.8 MB)
│   ├── flowork-wm           # Compiled Window Manager binary (515 KB)
│   ├── flowork-sysd         # Compiled System Daemon binary (9.9 MB)
│   ├── flowork-connector    # Compiled AI switchboard gateway (:9099)
│   ├── fl-inspect           # Forensic binary & system inspection CLI
│   ├── fl-edit              # Sovereign file & code editor CLI
│   ├── fl-media             # Sovereign audio/video manipulation CLI
│   ├── fl-hardware          # Hardware telemetry & control CLI
│   ├── fl-quant             # Model quantization & performance CLI
│   ├── flowork-chrome       # Headed Chrome launcher with CDP bridge
│   ├── flowork-sidebar      # Agent Sidebar GUI launcher
│   └── flowork-session      # Desktop session entrypoint
│
├── canvas-ui/               # Flowork Sovereign Desktop UI & Tool Schemas
│   ├── member-area/         # Sidebar HTML, chat, and status interfaces
│   ├── tools/               # Modular tool UI & manifest.json declarations
│   └── canvas.js            # Desktop canvas controller & WebSocket client
│
├── session/                 # Session runner and desktop entries
│   ├── flowork-session.sh   # Integrated desktop session runner
│   ├── flowork.desktop      # Display manager session definition (/usr/share/xsessions/)
│   ├── install-session.sh   # Session installer script
│   └── test-session-xephyr.sh # Isolated nested session tester (Xephyr)
│
├── builder/                 # Standalone bootable ISO compiler pipeline
│   ├── build-iso.sh         # 8-stage automated hybrid ISO compiler
│   ├── packages.list        # Minimal distribution package manifest
│   ├── flowork-publisher.sh # Sovereign Dual-Repository Publisher & Gatekeeper
│   └── README.md            # ISO build documentation
│
├── skills/                  # Sovereign Modular Skills (Strict 20 Keywords Standard)
│   ├── youtube_studio_uploader/   # YouTube video upload & publishing via CDP
│   ├── gdrive_rotator_stewardship/# Multi-account Google Drive cascade offloader
│   └── flowork_hardware_stewardship/ # Deep hardware telemetry & control
│
├── system/                  # Systemd services, prompts, and trigger rules
│   ├── systemd/             # flowork-core.service, flowork-sysd.service, etc.
│   ├── live_wallpaper/      # 3D live wallpaper telemetry server (:18099)
│   └── system_promp/        # Dynamic markdown directives and triggers
│
├── theme/                   # Sovereign branding, wallpaper, and LightDM styling
│   ├── lightdm/             # Slick-greeter branding & configuration
│   └── wallpaper-flowork.png# Official Flowork OS wallpaper
│
└── .fl_brain/               # Sovereign atomic memory vault (1 file = 1 solution)
    └── memories/            # Verified solutions with technical frontmatter

# Check Flowork Core Engine (:19890)
curl -s http://127.0.0.1:19890/api/copilot/health

# Check Flowork Pure Rust System Daemon (:18090)
curl -s http://127.0.0.1:18090/health

# Check Audio Status via Native Rust D-Bus
curl -s http://127.0.0.1:18090/api/system/audio

# Check Managed Windows via Native Rust X11 Socket
curl -s http://127.0.0.1:18090/api/system/windows

# Run isolated stability stress-test on nested display :5
/opt/floworkos/.FL_BIN/scratch/test_wm_stability.sh

# Compile Core Engine
cargo build --release --manifest-path /opt/floworkos/core/Cargo.toml

# Compile System Daemon
cargo build --release --manifest-path /opt/floworkos/sysd/Cargo.toml

# Compile Window Manager
cargo build --release --manifest-path /opt/floworkos/wm/Cargo.toml

1. Dual-Repository Sovereignty: All internal code, builders, and full engine reside in private vault backupflowork. Public releases are sanitized via Zero-Leak Gatekeeper to flowork-os. Direct unverified pushes are strictly blocked.
2. Zero-Trust & Empirical Evidence: Every claim of completion must be verified with terminal Exit Code 0.
3. Doktrin Anti-Zombie: Legacy files, dead scripts, and zombie processes are permanently deleted as soon as replacement components achieve Exit Code 0.
4. Kesucian @lock: Lines and files marked with @lock or @freez are inviolable.
5. Strict English: All source code, logs, user interfaces, manifests, and documentation must be written strictly in technical English.

Flowork OS — Engineered for absolute sovereignty by Awengkaudico & TeguhFX. Co-authored by Dr. Flow.