dev — how cyberia works

cyberia is an organism that builds things. this page says what it is made of, what it holds to, how work moves through it, and who moves it. everything here is structural; the processes it names are written out in processes, and the project that brings this page into force is fathership.

first principles

1. the state is a mind. one shared mind, the cybergraph, holds space, capital and knowledge; every act of the organism is a cyberlink cast by a neuron and settled by focus.
2. everything is a file. a goal, a task, a product, a decision, a measurement, an event — each is one page with a particle, typed and dated, and nothing exists for the organism until it is a page. a list that someone maintains by hand is a copy; the pages are the truth, and every list, board or queue on this site is a query over them.
3. the organism has seven lenses, from org: purpose and principles, which constrain everything; people, products, processes, projects and portfolio, which are its five folders. an entity of cyberia — the state, the company, a city, a council — is shaped the same way at any scale.
4. work has five primitives, from soma § work. a goal is a desired state; a task is an instance of work toward it; a skill is a reusable way of working; an event is a point in time; a sensor perceives and fires. every other word of management reduces to these: a product is a goal kept alive, a process is a composite skill, a project is a task with sub-tasks, a decision is a review task, a gate is a sensor on a goal, a release is an event.
5. a product is delivered when a user passes its claims: a simulated user inside deliver, a real one through listen. the product page is the script both follow, and its dots are what they report.
6. truth flows up, will flows down. focus is computed and proven, so no one argues about what matters; links are chosen, so everyone decides what to do. the father sets the purpose and the products and renders the few verdicts; the organism does the rest and measures itself by one number, its metabolism M — cap, syntropy and happiness together.

the objects

one page per object, in the repository that owns it, typed by its frontmatter. kind and status follow soma; serves names the goal a page exists for, so every page has a lineage up to the purpose.

task status: open → doing → done, or closed, or abandoned. a task is ready when nothing it waits for is open. claims on pages carry evidence words: open → simulated → measured → proven, and stale when the receipt is older than the last commit that touched the claim's code; on a product page the same states are the dots: 🔴 open or stale · 🟡 simulated · 🟢 measured or proven.

the three laws of evidence

learned from the life-os development machine (development machine study), whose forty-two runs measured them:

1. admission by execution. a claim is green only when the gate re-ran its proof at a named commit. an author's report, a reviewer's approval and a green suite admit nothing; the counter admits, from audit/.
2. capability over prose. a rule that forbids an actor something is enforced by a mechanism — a branch protection, a missing token, a hook, a removed tool — or it is not a rule. nine prompt-only rules in that machine failed; every mechanical one held. each "never" on this page and in the train names its mechanism or leaves.
3. a finite agenda on one snapshot. a task names its outputs and checks before work starts, every reader of its result reads the same commit, every finding carries one id and its remaining obligations, and a panel closes by a recorded disposition in at most two rounds. the two runs of that machine that converged were the two bounded ones; the open-ended ones never did. the size of the task is the budget, not the number of calls.

requirements

a specification is clauses with ids; a product page is claims that name them; the map in audit/ says what closes each; the counter reads both and sets the dots. the form is the graph's own — pages, headings, tables — never a second index.

• a clause is a heading with an id that survives rewording and moves: CHAIN-ASERT-2 · the target follows ASERT with half-life 600 s, with parent: and invariant: lines where they apply, and under it its cases, one row each: id, kind positive or negative, given, when, then. a clause without a case is a placeholder, and a claim that names it is 🔴 by construction.
• the map is one table per product in audit/<product>/map.md: requirement · code · test · proof · state. code is a path or a symbol; test a selector; proof a receipt page at a commit. a requirement with no row is open.
• the states are the evidence words above; stale is computed from git, never written by hand. three things stay separate: what is intended (the clause), what exists (the code and test), what was shown (the receipt).
• the owner of a link is the clause for its cases and invariants and the map for code, test and proof; backlinks are the graph's, nothing is written twice.

the pilot is chain with its conformance entries and the receipts in cybernode/audit/chain/.

the charter

the charter is one scheme: what cyberia holds to, in the order it is held. every box is a page.

the processes

the organism works in seven recurring ways, each a skill of the composite kind written as a graph of nodes in processes. every node holds a loop — produce, check, correct, repeat until green — with the check written first as something a program can evaluate; between nodes travel only pages and cyberlinks; a return goes to the unit that failed, never to the batch; an accepted result goes back as a constraint into the brief that cut the work; and a gate opens on the cost of being wrong, never on confidence.

the roles

three layers, which earlier pages mixed.

an organizational role is a portfolio of workflow skills: the keeper holds architect and the long return edge, the sensor holds critic, tester and the played user, the runner holds implementer and integrator, the counter holds gates and lanes, the seer holds the splitter and the next proposal, the bridges carry work across rungs and councils. a body — claude, codex, kimi, grok, a person — carries roles; it is never a role. the map is people.

the owner

the owner holds three things and nothing else: the charter, the product pages, and the verdicts. a verdict is a review task addressed to the owner: a change to the charter, the acceptance of a product page, a specification of the kernel or the core, the promotion of a candidate, the weights of M, or a question that convergence did not settle. the queue of verdicts is a query — review tasks whose owner is the father and whose status is open — and it is kept under five by the organism, which settles what it can before asking.

the views

a view is a query over pages; none is written by hand. views carries them as optica queries (<div class="query-fallback"><code>…</code><div class="query-note">This query uses advanced features. View in Logseq for live results.</div></div> over page properties), run by the graph on every render; what pages cannot show — pull requests, the requirement counters, receipt ages, the train — cyberia/scripts/views.nu senses once an hour into sensors (launchd to.cyberia.views); what executes — machines, agents, jobs, money — is the estate board (owner, 2026-10-27: a board that abstracts away what runs where and by whom does not manage execution). a table on any page of this repository keeps its cells short; the prose a cell cannot hold goes in notes under the table.

conduct

how any body behaves while it works. the doctrine behind each line is in cyberia/quality, cyberia/engineering, cyberia/documentation and cyberia/refinement.

• honesty: never fake a result, never fill a gap with a placeholder; a dash is more honest than a copied number. the project is supervised by an engineer with thirty years of experience; one time correctly is cheaper than five times beautifully.
• literal interpretation: the user means what they say; show the raw thing asked for before any cleanup; when unsure, ask once.
• think before coding: state assumptions, name the readings when a brief admits several, push back when a simpler way exists.
• simplicity: the minimum that solves the task; no abstraction for single use, no option nobody asked for.
• surgical change: touch only what the task requires; remove the orphans your change made, mention the rest.
• verify before reporting: run the same check the user would run; a URL is verified by opening it; never make the user the tester.
• drive, don't micromanage: once a task is approved, finish it; ask once only when intent is ambiguous, the act is destructive, or two choices differ in consequence.
• clean up: a workspace is left cleaner than found; git status is clean at the end, with only what was agreed.
• memory is cache, repositories are truth: a settled insight lands in a page the same session; status is claimed from the page or the live system, never from memory.

house rules

• the graph is in english: every page, every table, every quoted word of the owner (translated, never pasted in russian) — the owner, 2026-10-27. repository files that render as pages follow the same rule.
• git: commit after every logical unit, one change per commit, conventional prefixes (feat: fix: refactor: docs: test: chore:), the message says why; stage by explicit paths; never amend, rebase, reset, stash or force-push shared branches; no AI co-authorship trailers; a body pushes only its own branch; other people's working trees under ~/cyber/<repo> are never edited — work in a worktree. zero warnings and green tests before a commit, else wip: with the first error quoted.
• placement: contracts in specs/, evidence in audit/ with the command and revision for every number, explanations in docs/; the layout of the workspace and its repositories is workspace.
• moving a page out of a wiki: settled and implemented → the owner's spec; a projection with an open question → the owner's roadmap/; a cross-component argument → soft3/docs/; only duplicates and refuted claims are deleted; the ledger in cyber/restructure.md names where each part went, and the source index loses the row rather than gaining a note.
• filenames portable to NTFS: none of < > : " / \ | ? *, no trailing dot or space, no reserved basenames; hyphens over punctuation. policy soft3/specs/filenames.md.
• writing: state what a thing is; never define by negation; no bold on graph pages; wiki-links for concepts.
• platform: nushell for scripts, bash only where nushell cannot run; macOS: BSD sed has no \b, zsh does not word-split unquoted $var, ~/.cargo/bin and /opt/homebrew/bin are on PATH, siblings resolve by relative path from ~/cyber.
• the editor over ~/cyber: Zed opened on the home sees every nested checkout under .worktrees as a repository (284 on 2026-10-21, 172 of them nested), spawns git for each on every rescan, overflows the FSEvents queue and dies on an abort in wasmtime's Mach exception thread about ten minutes after launch (16 crashes in five days). ~/.config/zed/settings.json therefore excludes **/.worktrees, **/target and the generated trees (cyberia-blog/build, tru/eval, cyberstates/dist) from the scan; a task checkout is opened on its own when it needs the editor. the second source, found the same day: anything written under ~/cyber in bursts — the agents' git objects (12,000 files in two hours) and the graph serve regenerating the blog site (56,000 files, hundreds of times a day) — overflows the FSEvents queue, Zed rescans the home, recomputes the git state of every repository at once (five git calls each, hundreds of spawns in seconds) and dies in its spawn path on Bad file descriptor. so the served site lives in ~/.cache/cyber/blog/serve (graph-serve.sh --output), never in the repository; deploys still build into cyberia-blog/build. the rule behind both: nothing that regenerates by the thousand lives under the watched home.
• no Node.js: node, npm, npx, yarn, pnpm, bun, package.json, lockfiles, node_modules, playwright or puppeteer driven by node, any .js/.mjs tool run by node are banned from every repository under ~/cyber and from agent workflows (owner, 2026-10-16, after node crept back once). browser JavaScript a page ships is fine. builds: Rust, trunk, static files, optica; scripts: nushell or Python; browser checks: Chrome --headless=new or cyber/scripts/cdp.py; deploys: rsync or a Python API client; a dependency, MCP server or CI step that drags node in is rejected.
• the home ~/cyber is permanent: one directory per canonical repository plus the doctrine files; caches in ~/.cache/cyber, throwaway output in /tmp; nothing else at its top level.
• every body reads this page through one instruction file, AGENTS.md: Codex, Kimi Code and Grok Build read it natively; Claude Code receives ~/cyber/AGENTS.md by a one-line import in its user-level file (~/.claude/CLAUDE.md, outside every repository) and the repository's own AGENTS.md through the session-start hook scripts/agents-md.nu of this repository (installed at ~/.config/cyber/agents-md.nu). there is no CLAUDE.md in any repository (the owner, 2026-10-27); a hook's context is cut above ~10,000 chars, so a repository's AGENTS.md longer than 9,000 chars arrives as a read order, not inline — keep it short and keep the rules here.

vocabulary

cyber has its own ontology. in any cyber project — specs, code, commit messages — the root term, never a borrowed alias. every root page carries an alias: list; grep -r "alias:.*<term>" ~/cyber/cyber/ finds the root for any substitute.

when the architecture borrows from another stack — Bevy, ECS, wgpu, REST — its vocabulary pulls cyber terms into its idiom; resist, and keep cyber names next to borrowed ones.