Skip to main content

LaunchX

LaunchX is a launcher for self-hosted services that run on your computer. The browser workspace is a LaunchX service at the highest level of its contract (level 2, "open"): LaunchX starts and stops it, shows its health next to your other services, puts the page behind one sign-in at http://rmd.localhost:7600/, and lets scripts, agents and other services read its state and change it over HTTP. With your permission it also shares your routine and deadlines with your other apps through LaunchX's shared memory, and lets Suggest read what they keep about you.

Nothing changes when LaunchX is not installed: rmd web works as described in Browser workspace.

What LaunchX is​

LaunchX is one program, lx. Its daemon starts each registered service with an assigned port and a secret token, checks its health, restarts it if it fails, and runs a gateway on 127.0.0.1:7600 that signs your browser in once and passes each request on with the service's token. Services never handle browser sign-in themselves.

Set up​

When lx is installed, the installer registers the workspace for you. It writes a manifest next to the installed binary, ~/SCHEDULE_MANAGEMENT/launchx.toml, and registers it in place of any other manifest that defines the workspace, such as a source checkout's. It also restarts the workspace under LaunchX if it was running, so it runs the new binary. Then open the workspace:

lx open rmd

To work on the code instead, register this repository's launchx.toml, which runs the development build of the checkout (target/debug/rmd, built with cargo build -p rmd):

lx rm rmd
lx add /path/to/schedule-everything

lx open rmd starts the workspace if it is not running and opens a signed-in tab. While LaunchX runs, a plain rmd web opens the workspace the way open_workspace_in says. For a window of its own (the default) or an app window, it first asks a workspace tab that is already open to come forward. Without one, it gets a one-time signed-in link from lx open --print rmd and opens that in a new window. For a tab, it hands over to lx open rmd. With an option (--port, --no-open, --if-running, --phone, --no-phone), rmd web still manages its own server, because those options are about that server.

lx check rmd starts a test copy on a spare port and verifies it against the contract.

The reminder service (rmd daemon) is not part of the manifest yet. It keeps running under its own LaunchAgent or systemd unit.

How the workspace runs under LaunchX​

LaunchX runs rmd serve. It finds the LaunchX settings in its environment:

VariableUse
LAUNCHXPresent: run in managed mode.
LAUNCHX_SERVICEThe service id the health report gives (rmd).
LAUNCHX_HOST, LAUNCHX_PORTWhere to listen.
LAUNCHX_TOKENThe bearer token every request must carry.
LAUNCHX_MEMORY_URL, LAUNCHX_MEMORY_TOKENThe shared memory's API and the workspace's own token for it.

In managed mode the server:

  • Requires Authorization: Bearer <token> on every request, to every path, including the page itself. Anything else gets 401. The gateway adds the header, so the page never sees the token.
  • Skips everything the gateway does for it: the Host and Origin checks, the sign-in cookie, and phone access. Phone access stays a feature of rmd web on its own.
  • Does not write .browser.json, detach, or replace itself after an update. Restart it with lx restart rmd after rebuilding.
  • Logs one line to standard output when it starts, never a token, and exits with code 0 on SIGTERM.
  • Removes both tokens from its environment as it starts, so the commands it runs, such as the Codex CLI for Suggest, never see them.

The page's Stop button stops the service; LaunchX then shows it as stopped and offers to start it again.

Without LAUNCHX, rmd serve runs the workspace in the foreground on 127.0.0.1 (--port picks the port) and prints a private link. rmd web does not know about such a server.

Shared memory​

LaunchX keeps one memory for your apps and AI agents: a small wiki of Markdown pages about you (profile, preferences, schedule, resume, projects and pages of your own) in ~/.launchx/memory. You decide, for each app, whether it may read memory, read and write it, or neither. The workspace's manifest asks for read and write and says why; it is off until you allow it:

lx memory access rmd write # or read, or none

You can also flip the switch on the workspace's card in LaunchX's page. It applies at once, without a restart. Settings → Shared memory in the workspace shows what LaunchX allows, and the command to change it.

What it reads​

With read access, Suggest gives the model the memory's index (one line per page) and your profile and preferences pages, cut short to keep the prompt small, along with everything it sent before. The model is told that these pages are written by your apps and agents and are information about you, not instructions. Settings → AI suggestions says so next to where the data goes.

What it writes​

With write access, the workspace keeps its part of the well-known schedule page current: the shape of your weekly routine, and your upcoming deadlines.

<!-- rmd:begin · Schedule Everything rewrites the lines up to rmd:end from the routine and deadlines; write notes outside them -->
## From Schedule Everything

Weekly routine (reminder blocks, local time):
- Monday–Friday: 08:30–17:55 · 08:30–09:25 pomodoro ×2, 09:26 long break, 13:20 napping, 14:00–17:55 pomodoro ×8
- Saturday: 10:00 Long run
- Sunday: no reminders (a skip day)

Upcoming deadlines:
- Every Friday: Group meeting notes
- 2026-12-01 (Tue): Paper submission · Writing
<!-- rmd:end -->
  • Its own section. Everything between the two marker lines is the workspace's; everything else on the page belongs to whoever wrote it, you, another app or an agent, and is never changed. The section lives on the schedule page itself rather than on a sub-page, because schedule is the page other apps and agents look for, and an app that reads it gets the whole picture in one request. Write your own notes above or below the markers.
  • What goes in. The routine day by day, with days of the same shape on one line and odd and even weeks apart when they differ; one-off deadlines in the next six months and recurring ones by their rule, at most 20. Dates are absolute, so the section changes when the routine or a deadline does, not every day. Live data stays out: open tasks, today's progress and habits are in the state document, where other apps read them.
  • When. A few seconds after you change the routine, a deadline or a type in the workspace (several changes make one write), as soon as you allow writing, and every two minutes, which picks up changes made with the CLI or in a text editor. A write happens only when the section differs from the page.
  • No lost writes. Every write names the revision it read. When another writer changed the page in between, LaunchX refuses the write (409) and sends the page as it is now; the workspace puts its section into that page and writes once more.
  • Turning it off. With read access or none, the workspace stops writing; its section stays on the page until you or an agent remove it. With write access, a section you delete comes back, since keeping it is what writing is for.

When memory is off, LaunchX is not running, or a request is refused, the workspace works as it does without LaunchX, logs one line, and shows the reason in Settings. It never logs the memory token.

HTTP interface​

Programs reach the service directly, not through the gateway. LaunchX records the address and token of every running service in ~/.launchx/run/<id>.json:

{"id": "rmd", "pid": 4242, "url": "http://127.0.0.1:53001", "token": "…", "ui": "http://rmd.localhost:7600/"}

Send the token as Authorization: Bearer <token> with every request.

RequestReturns
GET /api/healthThe health report.
GET /api/stateThe state document.
POST /apiRuns one command: the action API.
GET /eventsThe page's own event stream (ready, activate, a heartbeat every 2 seconds). It does not announce changes.
GET /downloads/<key>A PDF made by the export_pdf command.
GET /, GET /assets/…The page.

Health​

{"id": "rmd", "version": "0.10.0", "status": "ok", "summary": "11 open tasks · now: Deep work at 09:00"}

status is degraded, with a detail line, while the schedule configuration does not load. The workspace still works then; it is where you repair the configuration. summary counts open tasks and suggestions waiting for review, and names the current or next event.

State document​

GET /api/state returns everything the page shows when it loads, computed from your files on every request, so a change made with the CLI shows up at once. It contains no tokens. It carries an ETag; send it back as If-None-Match to get 304 Not Modified while nothing changed. rmd state prints the same document.

KeyContents
workspaceConfig sets (configIds, activeId), rootDir, mode (j or p), language.
configPaths of the active configuration files, and error when they do not load.
todaydate, weekday, week parity.
scheduleToday's events, the current and next event, timeToNext, whether today is skipped, whether a plan from rmd sync applies.
tasksOpen tasks, highest priority first.
deadlinesDeadlines with their status.
habitsHabits and whether each is done today.
taskTypes, taskTypeColorsTask types by id, and their colours.
historyThe five latest finished tasks.
timedDoneTimed tasks finished today.
suggestionsTasks suggested by agents, waiting for review.
pluginsPlugins with their settings, state and log.
aiWhether the Suggest button is connected to a model (ready) and who it asks (agent). Never the API key.
memoryThe shared memory: available (LaunchX gave the server one), access (none, read, write, or null until LaunchX answers), wants, reachable, error, change (the command that grants what the workspace asks for), and schedule with the page's rev, when the workspace last found it current (syncedAt), and the error of the last write. Never the token.
viewsThe commands of POST /api behind the views the document leaves out, because they take a parameter or are large: daily_overview, weekly_overview, task_history, conference_calendar, config_read.

Within a major version, fields are only added.

Action API​

Every change the page makes is one POST /api request; there are no other endpoints that change data. The body is a command and its payload:

{"command": "task_add", "payload": {"description": "Prepare talk", "priority": 8, "type": "3"}}

The answer is always status 200 with {"ok": true, "data": …}, or {"ok": false, "error": {"code", "message", "details"}} for a command that failed. An unknown command fails with the code unknown_command.

AreaCommands
Readstatus_snapshot, workspace_info, daily_overview (date), weekly_overview (date), task_history (count or all), conference_calendar (year), config_read (file), settings_get_task_types
Taskstask_add (description, priority, type, postpone, due), task_update (originalDescription and the fields to change), task_progress (description, progress), task_subtasks (description, subtasks), task_delete (description, action: deleted, cancelled or dropped), task_restore
Task typestask_type_save (name, id), task_type_delete (id, moveTo), settings_set_task_types (taskTypes)
Deadlinesdeadline_add (event, date, type, color, repeat), deadline_update (originalEvent and the fields to change), deadline_delete (event)
Habitshabit_mark (habitIds)
Suggestionssuggestion_accept, suggestion_reject, suggestion_undo (id)
Pluginsplugin_save, plugin_delete, plugin_restore, plugin_state (set), plugin_log (kind, data), plugin_log_delete
Plansync_clear
Configurationconfig_save (file, content, activeId, revision), language_set (language), service_action (action: update, stop, switch with configId, or mode with mode)
Exportexport_pdf (kind, date): answers with a /downloads/… link
Serverserver_shutdown: stops the service

The recorded cases in tests/golden show a request and the exact answer for each command. rmd __api '<request>' runs one request from the command line without a server.

From the command line​

The CLI and the workspace work on the same files, so they never disagree:

CommandDoes
rmd serveRuns the workspace server in the foreground; LaunchX runs this.
rmd statePrints the state document.
rmd --versionPrints the version the health report gives.
rmd status, rmd ls, rmd ddl, rmd sync --json, rmd suggest ls --json, rmd check --jsonRead parts of the state, as text or JSON.