zgo — Documentation

>_ZGO REFERENCE

A from-scratch launcher in Rust behind a cyberpunk HUD, replacing Alfred — workflows (objects + connections), Script Filter feedback, fuzzy matching, variable/token expansion, web searches, clipboard history, snippets with auto-expansion, a keyword-driven developer-tool battery and Preferences panes that analyse the ranking function itself. A Tauri v2 desktop app over the pure-Rust zgo-core engine.

What it is

zgo is a keyboard-first launcher that reimplements the Alfred workflow model in Rust. The launch bar runs fuzzy-matched actions, web searches, clipboard history, and snippet auto-expansion; workflows wire objects and connections together and exchange Script Filter feedback (JSON and the legacy XML form). The engine is extracted into a pure-Rust zgo-core crate so the same launcher logic embeds inside the other MenkeTechnologies desktop apps.

Features

Workflows

Objects + connections with Script Filter feedback (JSON + legacy XML).

Fuzzy matching

Ranked matching across every launchable item.

Variable expansion

Variable / token expansion in actions.

Web searches

Search the web straight from the launch bar.

Clipboard history

A background pasteboard daemon logs every copy; browse it newest-first with clip / cb. ⇧↵ pastes the result straight into whatever app was frontmost.

Snippets

Snippets with auto-expansion as you type.

Developer tools

Dozens of inline tools behind a leading keyword — uuid, pw, hash, hmac, b64, case, color, contrast, palette, base, ip, unit, char, cron, tz, jwt, url, re, diff, json, qr, stats and more. ↵ copies or runs, ⇧↵ pastes.

Live cross-app verb search

The launcher indexes every running app's live verb surface, asked of the process at query time over its GUI-Automation-Bus socket — no static manifests, no per-extension interpreter. Rows rank beside your files through the same matcher and frecency blend.

Cross-app transactions

zgo is the suite's saga coordinator: an ordered list of verbs spanning several running apps, run as one unit. saga.plan preflights every step's reversibility against the live surfaces; on failure saga.run unwinds every app that already acted, in reverse order, through each app's own declared inverse. Reachable from Preferences, from zgo_saga_*, and as the bus verbs saga.plan / saga.run.

Attested rollback

A reversibility class is a claim and an abort report is the app's own count of what it undid. saga.probe measures instead: it runs each step for real inside its own transaction, aborts it, and re-reads every state that app publishes about itself — naming an inverse whose undo is lossy or a pure that quietly mutates. States that move on their own are detected by reading each twice and excluded by name; an app with nothing readable measures unmeasurable, never clean.

Blast radius

A transaction journal is per process, so a verb whose effect leaves its own process is outside every journal in the suite: its app unwinds and attests clean while another app is left changed with nothing that could put it back. saga.blast trials each step against the whole live fleet and names the edge — this verb, in this app, moved that state, in that app.

Compositional reversibility

Those all trial one step at a time, so all of them can report that every step in a plan is individually reversible while the plan still does not unwind. saga.compose measures the sequence: each step alone, then the whole plan, then one step dropped at a time until no single removal keeps it dirty — and a re-trial of the result, because a finding that does not reproduce is reported as unstable rather than as a finding.

Launch Timeline

Recorded queries on the shared zpwr-clip-engine arrangement grid — the DAW's canvas renderer, model and interactions, driven by a zgo domain: one lane per query, one cell per hour of the day.

Smart query router

A keyword-free result row for colours, unit conversions, number bases, IPs and Unix timestamps, resolved through the engine's query.classify.

Matcher introspection

Preferences panes that replay through the live matcher: Keystroke Optimizer (match.minquery), Typo Robustness (match.stability), Prefix Trajectory (match.trajectory) and Catalog Drift (match.regress, baseline via ⌘⇧B / audit via ⌘⇧D).

System actions

Sleep / lock / empty trash / eject / toggle dark mode / restart / shut down, from the tray submenu and the sys … keyword — catalogue sourced from the engine, never hard-coded.

Terminal · files · hooks

A PTY-backed login-shell terminal, the shared multi-pane file browser, and the stryke Monaco hooks editor, each opened from the tray.

Embeddable core

zgo-core builds rlib + staticlib + cdylib and mounts into the other GUI apps.

Architecture

zgo is a two-part split: the zgo Tauri v2 desktop app (HUD front end + window/hotkey integration) over the embeddable zgo-core engine (workflows, Script Filter feedback, matcher, variable expansion, clipboard, snippets). The same engine drops into the rest of the MenkeTechnologies app stack through its C ABI.

The GUI Automation Bus wiring is six modules in app/src-tauri/src/, one per leg: bus.rs serves zgo's own surface, busdiscovery.rs dials every peer for its live verbs, saga.rs coordinates a transaction across several peers at once, attest.rs digests each peer's published state before a run and re-reads it after the unwind, blast.rs widens that trial to every app the step was not aimed at, and compose.rs reduces a plan that does not unwind to the smallest set of steps that carries the failure. The three that hold sockets open across calls are saga.rs, blast.rs and compose.rs, because a transaction is per-connection state in zgui-bridge — and attestation rides those same connections, so it reads the exact process the steps ran in.

// ZGO — LAUNCHER IN RUST