--- title: adotom automaton · -bedrock kind: project-bedrock captured: 2026-05-21 captured_by: Shalaco · (silicon alchemyst run, reverse-socratic lead) operating_mode: executing-as-architecting back_reference: ../_principia/executing-as-architecting.md also_called: [adøtom, ado-tom, the workboard cradle] --- # adotom automaton · -bedrock > Note on the rename: the original folder was `adøtom automaton`. The ø was > swapped for `o` because the slashed-o gets URL-encoded as `%C3%B8` in href > chains, mangles on SMB shares the Synology serves over, and trips shell > autocompletion on the rsync airlock. The name keeps its shape (a-d-o-t-o-m) > and now travels cleanly over wire, file, and CLI. ## Operating mode **executing-as-architecting** (see `~/Desktop/root/_principia/executing-as-architecting.md`). Three at once: execute the build, draw the system under it, write the SOP into the build. Never ship raw MD — pipe through the viewer skin. Find the existing grammar before inventing. The cradle already exists; this project slots into it. ## What this project IS A **to-do automaton** built from the captain's existing 6D schema (the Principia Triskelion — six pairs across three lobes). Every to-do item is a *node* in that schema, not a row in a flat list. A node carries six axis-values, and one canonical ID can render simultaneously as: a to-do row, a mythical character entry, a calendar block, a journal seed — because the axes are projective and the view is downstream. The view that ships first is the to-do view. The active-task clock is the load-bearing diegetic affordance: when a task is in flight the clock is visible, and only then. (TOTK: stamina wheel appears while climbing, not before.) ## Principle 1 — The schema is the architecture; the view is the surface Views are interchangeable. The 6D node is not. Any view we ship reads from `schema/nodes.json` and writes back through the same fields. We will write multiple views (to-do, hologram, mythos) over the same nodes. The view that fails the captain is replaced; the schema stands. ## Principle 2 — Local-first, server-portable Built to run from `python3 -m http.server` on this laptop today and to lift unchanged to the Synology Web Station next week. No server-only state. No external DB. Files on disk are the system of record. Cron backups, not cloud trust. Plug-points (`adapters/`) are stubs until the captain confirms. ## Principle 3 — Disclosed gaps over polished fiction Where a value is unknown (Clockify workspace ID, Asana project GID, Synology hostname), surface a placeholder marked `# CONFIRM`. The estimate-with- disclosed-unknowns ships and gets corrected. The perfect estimate never ships. ## Principle 4 — Never ship raw MD to the captain Every MD in this project is reachable through `/views/cradle.html` (a fork of the cyrelium-md-viewer skin already in `_ptah/`). The captain gets one URL. ## Principle 5 — The clock is diegetic When a task is active, a small clock is visible (top-right of the view, dim when paused, glowing when running). When no task is active, the clock is absent — not greyed-out, *gone*. This honors `UI that is better when it's not there.` The Clockify adapter, when wired, mirrors the same state — start a local timer and the adapter pushes a Clockify time-entry; stop the local timer and the adapter closes the entry. ## Principle 6 — Clock-care for memento-brain (captain-stated 2026-05-21) The captain often finds clocks still running the next day; he names the failure mode *task-jacking + memento-brain*. The clock therefore takes care of itself in three moves: 1. **Gentle reminders at 5 / 15 / 50 minutes.** A warm low prr (110 Hz + 165 Hz overtone, ~6 Hz tremolo, slow attack/release, peak gain 0.06) plus a soft gold pulse on the clock chip. The reminder is *information in the world* (TOTK diegetic feedback) — it does not interrupt, it just reports that the clock is alive. 2. **Auto-stop at 4 hours.** If the clock has been running 4h, it stops itself. The node gets a `clock-auto-stopped` tag, the body gets a timestamped note, the last `time_log` entry gets `auto_stopped: true`. Three soft farewell prrs. 3. **No willpower required.** Captain never has to remember to stop the clock for the system to do the right thing. The captain *can* still stop early at any time — the auto-stop is the safety net, not the verb. Falsifier: if after one week of use, any node has more than one `clock-auto-stopped` tag *and* the captain still has a clock running on a forgotten task the next morning, the prr is not warm enough or the cap is wrong — adjust the thresholds, not the principle. ## What the captain receives at the end of this run - `/views/todo.html` — the working to-do view, with always-on active-task clock - `/views/cradle.html` — viewer-skinned reference to every MD in this project - `/schema/nodes.json` — seeded with the 6D schema, ready to grow - `/server/serve.py` — local HTTP server with a PUT endpoint for writes - `/server/Launch-adotom.command` — double-click to run on Mac - `/server/cron-backup.sh` + a launchd plist — hourly snapshot into `/backups/` - `/adapters/asana.py` + `/adapters/clockify.py` — stubs with the schema-shaped functions - `/docs/README-SYNOLOGY.md` — Web Station + Task Scheduler walkthrough ## Held open (disclosed gaps) - Asana workspace + project GIDs (captain confirms; `adapters/asana.py` carries placeholders) - Clockify workspace ID + API key (captain confirms; `adapters/clockify.py` carries placeholders) - Synology hostname / share path / web-station port (captain confirms; README carries placeholders) - Multi-device write concurrency — single-writer assumption until the second device shows up - The `entry.json` sidecar convention from corpus-constellation-cradle is read into this project's nodes but not yet round-tripped back to the cradle (cross-project link, deferred)