Open Commons ObservatoryEnglish·Русский

Concepts and decisions

Its concepts, and the decisions taken - with what was rejected.

Glimpses, then changes, then releases

Work is recorded where it is fresh, as glimpses - at any moment, through ocoeco, not only when committing: research, prose, essence, code. A change (what lands) is the glimpses it carries; a release is the changes it ships. Git operations depend on ocoeco; ocoeco does not depend on git.

A program knows what it does

A test need not be a dead end beside a program: what a program does, looks like and how it meets others can be part of how it works - so it can say what is actually happening and how well, in words another program can use, and mend itself by a countermeasure that is declared and seen. Begun here without the name: ocoeco check brings every lens into focus; a write that would add a link to nowhere is refused, with why; oco-agent's pulse says it is well; the fulldome's screen is read back by a terminal emulator. Since 2026-11-12 a projection looks at itself before it reaches a surface (decision 2026-11-12-the-projection): the first place this is how the program works, not a test beside it.

Chainability

One project's data can feed another's - device tests into a grand project's path, a tool's releases into a lab's - each row carrying where it came from.

Data made by work

A project's data is produced by its work - commits, builds, tests, releases - not typed up afterwards; what only a person can supply is written once, where the work happens.

Manual-work saturation

A project's ledger of small actions done by hand, each counted. Doing one again bumps its count; past three it is saturated and asks for a tool. A record automated by a tool says so - and a later bump asks why it was done by hand again. Deliberate hand-work (looking, listening, deciding) is counted but never asks. Saturation is effort, not only count: minutes weighted by load (0-10, Borg CR10).

Lenses are additive

ocoeco is a rhizoid: anyone can write a lens, keep it to themselves or offer it upstream, and still pull updates - because a changed lens is a new lens, never an old one rewritten. A lens may add tables or fields but never changes what an existing one means, and it says which lens it grew from, so many near kin stay a family one can choose within rather than a pile.

Data made by work

A project's data is produced by its development and its functioning - commits, builds, tests, releases, measurements - as a principle and by tools, never kept by hand.

The observatory is a mirror

Projects produce their data; the observatory reads it. Everything breathes through ocoeco - its language, gatherers and checks - and no project needs the observatory to work.

One language, so the pieces join

Plain text tables, a mark, shared names for the common things (idea, path, workings, work), and data that feeds other projects' data with its origin on every line.

Prior art travels with the ideas

A project's sources are what people already learned that it stands on, and what it takes from each; concepts and decisions cite them, so the research behind an idea is seen where the idea is.

Look around first

Before acting: what is, what we are dealing with, why it is so, and what others already learned - kept as research (the question, what was found, its sources), cited by the decisions that rest on it, shown beside the steps those decisions are about.

Research has versions

A refresh adds a new version and never overwrites; earlier versions stay one click away. Views of facts follow the latest version; a decision keeps citing the version it rested on, and says when a newer one exists.

tad, the format

Text as data - tables as JSON lines with a schema, a canonical form and verification - is the format ocoeco speaks.

The same at every scale

Places nest by gathering - a star produces, a constellation gathers stars, an observatory gathers constellations and observatories - and lenses nest by composing, the fulldome being the outermost. So one act (observe) and one way of seeing (a lens) serve every scale, and nothing special is needed at the top.

Three ways of knowing

Live: gathered from a marked project as its work happens - the default, unmarked. Researched: taken from outside the commons, dated, with how it was found and its sources - shown outlined, with its age, linking to the research. Unknown: neither, and said so.

A vocabulary every project speaks

Each project keeps its words and their exact meaning - what a word means in plain language, what it is not, what it is easily confused with. ocoeco defines the shared words (mark, lens, essence, working, cutting, conveyor...); projects inherit them and add their own; a redefined shared word is flagged. Shown as a page, and as the terms underlined in the project's own pages with their meaning beside them.

Every change carries a record made by ocoeco (a changes table in the shared language), the commit message is rendered from it, and ocoeco release consumes the records to set the version, write release notes tied to milestones and backlog, and tag - taking over from release-please and release-plz. The guarantee is at the boundaries that cannot be skipped: land refuses a change with no record, and a CI check on every pull request does the same; a local hook only points the way. Local commits stay free; the record is per change. Refined the same day by 2026-11-11-glimpses: the record is the glimpse, made while the work is fresh; a change is the glimpses it carries.

The author: data about work goes stale because nothing guarantees it is produced; release tooling writes prose nobody consumes, while ocoeco already knows tasks, goals, decisions and effort. 48% of recent landings produced any data.

Rejected: Records only in commit messages (lost to squash merges, readable only through git); refusing every local commit with hooks (they fight rebase and amend, are bypassed with --no-verify, and the bypass becomes routine); adopting changesets or Knope as they are (a bump and a summary, tied to nothing else); keeping release-please (prose that drives nothing).

2026-11-11

ocoeco check reads a project's essence as advice and never fails on a gap.

A gap is the truth about a project, not an error in its data.

Rejected: Failing the check until every step is served.

2026-11-11

Code is changed by structure: whole items replaced with ast-grep, matched by their signature; logic kept outside macros where tools and readers see it; new views and tools added as new files; every edit verified before anything lands.

Patching source by matching text was the heaviest manual work (19 times) and the cause of most failed runs, one of which landed a commit that changed nothing.

Rejected: Text patches with better anchors; Comby (language-agnostic, less exact for Rust); writing our own rewriter.

2026-11-11

Hand-work saturation is measured in effort - minutes weighted by load on Borg's CR10 scale - as well as count; there is no deliberate status: looking, listening and deciding are counted and automatable like the rest.

The author's 30 kg box: ten seconds, yet draining. And tests must judge sound and pictures themselves, with no person judging mid-run (jidoka).

Rejected: Count alone; NASA-TLX's six ratings on every bump (too heavy); exempting judgment from automation.

2026-11-11

The record of work is the glimpse, made through ocoeco at any moment while the work is fresh; ocoeco supplies most of it (what ocoeco note wrote since the last glimpse, the backlog items and milestones they serve, the effort), and the person or agent types a line. ocoeco commit renders a commit from the glimpses not yet committed, with a trailer per glimpse; ocoeco release consumes the glimpses of what has landed. Git depends on ocoeco, never the reverse: a glimpse needs no git.

The author: capture data where it is fresh, while the work is remembered, not sorted out afterwards; and git operations depend on ocoeco, not ocoeco on git. This refines 2026-11-11-changes-are-records, whose record was tied to a change.

Rejected: One record per change, written at commit time (later than the work, and tied to git); records only in commit messages; hooks refusing every local commit.

2026-11-11

Hand-work becomes part of ocoeco's language: a handwork table of atomic actions with counts, recorded by ocoeco hand (match, bump, or ask), shown by the observatory as hand-work worth a tool.

Proposed by the author. A board task is many steps and never repeats; atomic actions do. The wording is kept from drifting by the tool, as the vocabulary keeps words from drifting.

Rejected: Logging whole tasks (they never repeat); free-text notes in the session log (they cannot be counted); bumping on any resemblance without asking (silent merging of different actions).

2026-11-11

ocoeco check names every table a repository keeps beside its exported ones but does not export.

A device lab's whole backlog and a tool's decisions and log went unseen by the observatory for days; ocoeco note found it by refusing.

Rejected: Exporting every file automatically - some are kept for a project's own use.

2026-11-11

The shared language is language.toml, a tad declaration; ocoeco note checks each row it writes with tad's check_row; the shapes kept as Rust constants are gone.

One way to declare and check tables across the commons: tad's, readable by people and by any tool. A test proved the file said exactly what the constants said before they were removed; ocoeco's own tests pass unchanged.

Rejected: Rewriting every project's tables in tad's canonical form now (churn in 22 projects, no reader gains); keeping the shapes in Rust (a second declaration language).

2026-11-11

Hand-work is called manual work everywhere - the table manual_work, the command ocoeco manual, land --manual; every record and bump appends a timed event to manual_events.

The author: manual work is the plain word, and with the time kept it can be set beside commits and releases. A command named manual could be read as documentation; the vocabulary defines it, and ocoeco has no documentation command to collide with.

Rejected: hand-work (less plain); ocoeco did (the person does, not the tool); inventing times for the history recorded before.

2026-11-11

Rows are recorded with ocoeco note, not hand-written per job.

Every job wrote its own script to patch JSON: the same handwork again and again, each a chance to break a table. On its first use the tool found that ocoeco itself exported no decisions.

Rejected: A per-job script; a general JSON editor that knows nothing of the format.

2026-11-11

ocoeco manual without an action opens a list in the terminal (ratatui): type to narrow, arrows, Enter, the usual minutes and load offered.

Asked by the author: typing an action again is a chore and splits the ledger into near-duplicates.

Rejected: A web form (not TTY-first); fuzzy matching on typed text alone (it guesses).

2026-11-11

Research joins the language as its own table (question, found, sources, date); decisions cite it and name the steps they are about; the observatory badges each step with its decisions.

Asked by the author: research should back decisions visibly, beside the milestones and progress they concern, and looking around should be a practice for agents and humans alike.

Rejected: Sources alone (a list of works says nothing of the question asked); a separate research page with no link to steps.

2026-11-11

Any row may be researched rather than live: it cites a research entry and is drawn outlined, with its age and a link; research gains versions (topic, date, supersedes), a refresh horizon, and a place in the attention view when it goes stale.

Asked by the author, to fill the picture honestly with what others achieved.

Rejected: Copying outside claims in as if measured; overwriting research on refresh; marking live data (live is the default).

2026-11-11

Vocabulary becomes part of ocoeco's language: a vocabulary table (term, means, not, see), the shared words defined by ocoeco itself, a project's own words beside them, translated like everything else, and shown in views.

Asked for by the author, so the work can be spoken about clearly; concepts and vocabulary answer different questions.

Rejected: Folding definitions into the concepts table; a glossary written by the observatory about projects.

2026-11-11

Where the whole is weakest right now is where attention goes.

What should be looked at next, read from every project - not what is loudest.

Rejected: triage (medical jargon); focus; priorities (a ranking someone sets)

2026-11-11

An idea a project rests on, with why it matters, is a concept.

Distinct from idea (why the project exists) and from vocabulary (what a word means).

Rejected: principle (a rule to follow, a narrower thing); belief

2026-11-11

A shared process that projects call, not copy, is a conveyor.

A conveyor carries any load the same way; you put work on it, you do not build your own.

Rejected: pipeline (CI jargon, and one run); template (copied, the opposite)

2026-11-11

A lens chosen to stand in the observatory's navigation is curated.

Says chosen with care, and nothing more; any lens is still found without it.

Rejected: featured, pinned (web jargon); official (claims an authority it does not have)

2026-11-11

An owned fork pinned upstream and changed only as patches meant to go home is a cutting.

Rhizoid's gardening word: a cutting is a living piece of the parent plant, grown in your soil.

Rejected: fork (suggests drifting apart); vendored copy (a frozen copy, nothing goes home)

2026-11-11

A choice taken, with why and what was rejected, is a decision.

The plain word; the rejected options are what make it worth keeping.

Rejected: ADR (an acronym a reader must be taught); choice (says nothing of the alternatives)

2026-11-11

Minutes weighted by load are effort.

Effort is the plain word for time and strain together - the 30 kg box.

Rejected: cost (money); toil score (jargon); workload (NASA-TLX's wider measure)

2026-11-11

A project's whole chain on one page is its essence.

Essence is what a thing most truly is; the page shows why, what, how and now at once.

Rejected: overview, summary (say less, not more); dashboard (numbers, no reasons); at a glance

2026-11-11

The daily job that writes down what a project's work produced is its gatherer.

One metaphor, kept whole: gatherers in each field, the harvest brought in by the observatory.

Rejected: collector (monitoring jargon); logger; recorder (plain, but breaks the metaphor)

2026-11-11

The observatory's reading of every marked project is the harvest.

It brings in what the gatherers gathered; the pair is easy to keep in mind.

Rejected: crawl, scrape (say how, not what); sync; import

2026-11-11

The three stretches of a path are horizons.

Horizons are near and far at once - working, perfection and ongoing perfection are all in view together.

Rejected: phase, stage (imply one ends before the next begins); level (sounds like a score)

2026-11-11

Why a project exists, told for anyone, is its idea.

The everyday word; a reader knows what an idea is without being taught.

Rejected: vision, mission (corporate jargon); pitch (selling); purpose (narrower)

2026-11-11

A grand view of a family of projects, declared as a small file, is a lens.

You look through a lens; many lenses can look at the same commons, and anyone may make one.

Rejected: view (every page is a view - two meanings); dashboard; portal

2026-11-11

How draining an action was this time is its load.

Short and physical, as in carrying a load; one number from Borg's CR10.

Rejected: exertion (formal); fatigue (an aftermath, not the act); difficulty

2026-11-11

The file by which a repository joins the commons is a mark.

Short and plain: a mark is something you put on a thing to say what it belongs to.

Rejected: manifest (a package's description elsewhere - two meanings); badge (a picture); tag (GitHub topics are only half of it)

2026-11-11

A step on a path is a milestone, reached only when its evidence exists.

The word readers know; the vocabulary adds only the rule that evidence reaches it, not a date.

Rejected: step (too small to name a stretch of work); goal (aims, not proves); checkpoint

2026-11-11

The mirror that reads and draws the commons is the observatory.

One watches from an observatory and changes nothing: the mirror, not the control centre.

Rejected: dashboard, portal, hub (suggest control)

2026-11-11

The commons' language and machinery keep their own name, ocoeco.

A proper name, chosen by the author: the observatory's ecosystem - the blood and heart.

Rejected: a descriptive name (it is the name of a thing, not a description)

2026-11-11

What a project must reach is its path.

A path is walked step by step and says nothing of dates - exactly a list of milestones with their evidence.

Rejected: roadmap (promises dates, a second meaning we do not want); plan; route

2026-11-11

A repository with a mark is a project.

The plain word everyone already uses; one repository, one project, one mark.

Rejected: repository (says where, not what); module; component

2026-11-11

The look around before acting is research.

The everyday word for looking into something before deciding.

Rejected: prior art (the sources, not the looking); investigation; due diligence (legal)

2026-11-11

Manual work done often or heavily enough to ask for a tool is saturated.

The author's own word; it says full - nothing more should be carried by hand.

Rejected: overdue (blames); hot spot (jargon)

2026-11-11

A work a project stands on is a source.

The word readers know from any citation.

Rejected: reference (also means a pointer); citation (the act, not the work)

2026-11-11

The words a project speaks and exactly what they mean are its vocabulary.

A vocabulary is a language spoken - the ubiquitous language of domain-driven design - not a list kept at the back.

Rejected: glossary (a list at the back of a book); dictionary; terminology (formal)

2026-11-11

What actually happens is work: the backlog, the log, what the gatherers record.

Plain, and set against the plan; the Essence page asks of it: what is happening now.

Rejected: activity (only commits); progress (a judgment, not a record)

2026-11-11

How the steps are delivered and proven are its workings, as in the workings of a clock; a single entry is called by its kind.

Workings is everyday English for the parts that make something work. Working as a singular noun is unusual and was the weakest word in the language.

Rejected: working (unusual as a noun); means (plain, but it would collide with the vocabulary's own means field - one word, two meanings); mechanism (sounds like code only); instrument

2026-11-11

Words are chosen like decisions: a vocabulary entry names the decision that chose it, the decision records the words rejected and cites research; every vocabulary is reviewed this way.

Asked by the author: wording is part of perfection. A word is how everyone after us will think about the thing.

Rejected: Definitions without reasons; leaving the words as they first came.

2026-11-11

A lens's focus is declared as data in its file: parts, each a query over the lens's gathered tables and one line laying out an answer ({name} is that answer's value; {count} in a heading; {today} supplied by the computer). ocoeco focus LENS gathers the lens's tables from this place, or from every place under a root - each row with its star - and runs the parts through tad's SQL engine. The work lens's focus replaces the hand-written board: on every star's main it printed the same 12 lines, byte for byte.

The same data, brought into focus (2026-11-12-a-lens-focuses), and proven equal before replacing, as tad's Rust version was. How it reads is now data: changing a word is editing the lens, not the program.

Rejected: A language of its own for layout (one line per answer is enough to equal the board; more is added when a lens needs it, not before); formatting in Rust (the hand-written view lenses exist to end); replacing the board before the focus equalled it.

2026-11-12

A lens may add meaning to what it brings into focus; only a surface adds looks. The first meaning: a line that is a measure of a whole (measure = COLUMN, of = N in a focus part) - shown by each surface in its own way: a native meter on the page, a bar of ten cells on text, Markdown and the terminal. The purpose lens says its milestones are measures of nine. A lens placed over other lenses - a colour lens, in the author's words - fits the same way: it adds what its colour means, never the colour. Later the same day the author set the colour lens aside (backlog a-lens-over-lenses, parked): the meaning is already carried by the lens that holds the data; nothing is built toward a lens whose work is beauty.

The author, 2026-11-12: we will be able to add more lenses, the naming again discovered naturally - a colour lens, a lens that uses other lenses to make what they already focus more beautiful or convenient, like the infographics the earlier page had. Astronomy does this with colour filters: the same light, through a filter, shows what the plain view leaves flat. The inset that had leaked from the text surface into every lens was removed the same day; beauty kept in a lens would bring layout back. A readiness bar is not decoration: it says this is a quantity of a whole. Proven: six other lenses print byte for byte what they printed, and every lens comes into focus over every star.

Rejected: Looks in a lens - colours, bars, spacing (a lens would know its surfaces again); an infographic as a surface of its own for one lens (it would not just work for the next lens with a measure); a word for the lens-over-lenses chosen before one is built (filter is the candidate, to be found in the making).

2026-11-12

The second face of a lens is its focus, not its showing; ocoeco's acts are glimpse, observe and focus. A lens lets data through and brings it into focus; what is seen is on the fulldome. Shine names no act: it is what a star does by working.

The author, 2026-11-12: a lens propagates light, by itself it shows nothing, and showing is a word from another domain. Optics defines a lens by exactly this - it transmits light and brings it to a focus (research the-word-focus). The word also parts two things that showing had run together: the lens that orders, and the fulldome where it is seen.

Rejected: show and showing; render; resolve; image; project and projection; reveal (each with its reason in the word's entry).

2026-11-12

A lens has two faces: its glimpse takes data in, its showing gives it out. The glimpse says the data's place and relations and how it is entered with ease; so a lens defines the data it needs, and the shared language is no longer written from outside - its tables and relations become the glimpses of the lenses that need them, regrouped, not rewritten. ocoeco glimpse brings all lenses' glimpses together: subcommands and flags declared with argenv, a collision found when ocoeco is built; with no arguments it opens a composed view of them all. The acts are glimpse, observe and show; ocoeco note gives way to ocoeco glimpse. One lens defines a piece of data; other lenses may read it, safely, because lenses are additive.

The author, 2026-11-12: the earlier concept of glimpses now has its place - a glimpse is a part of a lens; our database structure had been dictated by us from outside the system, and now fits in naturally; a glimpse also defines how to gather data with convenience - not retyping what already is, not dialling in what the computer can get; collisions are flagged in the making, never in use. It also answers a caution of the same day: a lens need not bring instruments of its own, because the entry follows from the declaration.

Rejected: The shared language kept as one file apart from any lens; note as the way in (it asks one to know the tables); a glimpse for each table (a lens with several kinds of row has one glimpse with several entries); lenses loaded while running (a place builds its ocoeco with its lenses - the rhizoid way - so nothing is loaded blind).

2026-11-12

A projection is the shape that focusing gives the data: lines, a measure, how they sit together. It does not check what it projects - whether the data is sound is the data's (tad's rules, the relations), whether all of it was gathered is observing's - only the shape it is projected in. So the shape is told with no data at all: each part's query has its columns whether or not anything answers it, and a part's line and measure may name only those (ocoeco check asks the engine to describe each query over empty tables). A shape is checked in the making and need not be watched after; the world is checked where it is met, each time, in observing.

The author, 2026-11-13: a projection does not check what it projects, it does not touch the data, it does not read text - it defines and self-checks the shape in which that data is projected; a shape like a progress bar, where we do not care what is in it; the shape that focusing gives data is a projection. This dissolves what was left open on 2026-11-12: what a lens expects of its own (at least one star, a total that equals a count) was asked of the wrong layer; and a part with no answers could not tell its line was wrong only because the shape was checked against a row of data. Proven: a misnamed column in a part with no answers, unseen before, is refused by its shape.

Rejected: Expectations about data declared in a lens (another layer's work); checking the shape against the first answer (no answers, no check); watching the shape at every focus as the whole of awareness (a shape cannot change between making and running - the world can, and that is met in observing).

2026-11-13

A lens's glimpse is its entries, declared in the lens: what an entry is called, the table it fills, what a person is asked for, and what the computer supplies and when - new, always, FIELD changes, FIELD becomes VALUE. The computer knows today and who; what a person gives always stands. ocoeco glimpse alone shows every entry of every lens; ocoeco glimpse ENTRY --id ID --FIELD VALUE makes one, and a field the entry does not have is refused with what it does ask for. Two entries with one name, or an entry filling a table its lens does not define, stop the build. The work lens's first entry is item: since and driver are supplied.

Not to retype what already is, nor dial in what the computer can get (the author, 2026-11-12). Until now since and driver were typed by hand on every move, and ocoeco note took any field name, so a mistyped one was written as a new field.

Rejected: A language of conditions (three plain ones cover the flow; more when a lens needs them); changing the shape of ocoeco glimpse "what was done" now (every job and every landing uses it: it goes on as before, and becomes an entry of the results lens when that lens gets its glimpse); flags built by argenv in this step (ocoeco's own command line is not on argenv yet: the collision is met at build all the same, by the build script).

2026-11-12

Every lens has its focus, and each brings what matters now rather than its whole tables: purpose - what each star is for and what is being reached; knowledge - what was looked into lately and the words with their meanings; reasoning - what was decided lately, what refines what, and how many decisions do not say what was rejected; results - what was done lately and what is still done by hand; looking back - the newest reflections and sessions. Each is three parts, a query and a line, and shows on every surface.

The fulldome said of five lenses that they had no focus yet. What was observed holds 95 milestones, 164 decisions, 142 glimpses, 173 sessions: laying all of it out would bring nothing into focus. What each lens is for comes from the research (the-fulldome-lens-by-lens).

Rejected: Every row of every table (a list is not a focus); a focus for each table (a lens with four tables has one focus, as it has one glimpse); leaving the dotted lenses for later (the fulldome cannot stand where the engine's views do while five lenses show nothing).

2026-11-12

The shared language is held by the lenses that need it: the fourteen tables and thirteen relations moved from language.toml and relations.toml into six lens files (lenses/*.toml) - purpose, knowledge, reasoning, work, results, looking back - each saying what it is and which lens it grew from. ocoeco reads its language by putting the lenses' tables together. A lens id used twice, or a table defined by two lenses, stops ocoeco from building.

A lens defines the data it needs (2026-11-12-a-lens-has-a-glimpse); the structure was dictated from outside in one file. Regrouped, not rewritten: a test holds the lenses, put together, to the language as it stood, table for table and relation for relation. A collision is met in the making, never in use.

Rejected: Keeping one file and tagging each table with a lens (the lens would still not own its data); checking collisions when ocoeco runs (met in use); rewriting any table while moving it (the proof would mean nothing).

2026-11-12

Reflection is an entity of the shared language (language.toml): id, date, by, over, saw, learned, changes, answers (other reflections) and touches (decisions, practices, backlog, research, glimpses - table:id in this project, project/table:id in another). Reflections are written into the data like everything else, so whoever comes next - a person or a machine - inherits the lessons, not only the state.

The author, 2026-11-12: reflect upon all that was done, as an entity related to the others. A session's lessons otherwise live in a conversation that ends; ocoeco is the place that lasts.

Rejected: Keeping reflections in the session log (a log says what was done, in order; a reflection says what it meant, across a stretch); a reflection per project only (a look back often spans several, so it touches across projects); a separate field for each voice (each voice is its own reflection, and answers the other).

2026-11-12

The relations of the shared language are declared as data (relations.toml): which field refers to which table - twelve, among them two that were missing: a decision refining or replacing another (decisions.refines) and work serving a milestone or decision (backlog.serves). ocoeco check verifies every link within a star, and with --root the links into other stars. A field holds several links separated by commas or spaces; table:id names the table; project/table:id points into another star. A milestone's criteria are declared too; what in them is a condition rather than a link to a row (feature:name@level) is passed over.

The fulldome is one sky only if what is connected is truly connected (research the-fulldome-lens-by-lens, ocoeco-as-a-database): about 860 links were kept by discipline alone. On 2026-11-12 one decision refining another was written as prose eight times over.

Rejected: Leaving relations to discipline; rewriting existing data to one separator (glimpses use spaces, reflections commas: both are read); putting the relations into tad's declaration now (tad's own references rule does not read lists or table:id yet - it should, later).

2026-11-12

What has run in each place is observed, not written: ocoeco observe (once harvest) gathers, for every place, the latest finished run of each active workflow on its default branch into the table runs, which the problems lens defines. A run that failed is a problem derived from the data - shown while true, gone when the next run passes - beside the problems people raise. The observatory observes, and so can the lab, with the same act; the lab will also say a new failure aloud.

On 2026-11-12 looking around found 111 runs failed on main in three days, three of them real and unheard for days (the phone docs' release 54 times; the harvest's guard 27). GitHub sends no notice that reaches anyone. The full picture must show it - a ping alone would be one more channel outside the picture.

Rejected: A notification only, from each failing workflow (a sound without a light: nothing in the picture, and gone once read); raising each failure as a recorded problem (a fact of the data copied by hand, never closed when the run passes); polling from the lab alone (the picture is the observatory's, for everyone - the lab adds the voice).

2026-11-12

ocoeco's acts are record, observe and show. Observe replaces harvest and discover. Record stays plain. Show stays plain until the first lens is built and run; shine is kept in mind for it.

One word, one meaning; a word someone can guess from what it does (research the-words-for-the-acts).

Rejected: pulse for record (taken by oco-agent's pulse, and it cannot be guessed); shine for show now (it reads as either of two acts); naming an act before touching it.

2026-11-12

The board is a view over every project's backlog (ocoeco board), never a list of its own. The backlog carries the flow - open, next, in-progress, waiting, parked, done, dropped - and four optional fields: driver (who holds it), next (its next step), since (the day it entered its state), waits_on. The board shows in progress by driver, waiting and on what, next, and what needs attention: more than three held by one driver, in progress with no next step or nobody holding it, nothing moved for a week. oco-agent speaks it when it changes. Refined the same day by 2026-11-12-the-room: the flow of work is one lens of the room, not the room.

The author, 2026-11-12: the board must come from ocoeco's data, with ocoeco and oco-agent developed hand in hand, after the best research. One truth: the backlog is already kept in every project as the work goes; a second list is a second truth that drifts (lab-agent's board was one).

Rejected: A board kept as its own list (lab-agent's board.json: a second truth); a column per project (the flow is the point, not where an item lives); priorities as numbers or points (the order is the next state, pulled; time is measured as age instead of estimated); hill charts now (worth adding once the flow is lived).

2026-11-12

The dome is the port and each surface an adapter: a lens brings its parts into focus (a heading and its lines), and a dome lays them out. Plain text and Markdown are surfaces behind that one port (ocoeco focus LENS --surface NAME), the terminal lays out through the text surface; HTML and CSS follow the same way. Lenses carry no layout of any surface: the two-space inset under a heading moved from the lenses' lines to the text surface.

The author, 2026-11-12: dome is the core term - the concept of a surface that stars' shine can be focused onto, the interface for surfaces to implement, be it Markdown, HTML and CSS, a terminal or whatever someone comes up with; and the fulldome is a lens that focuses all lenses onto all their surfaces. That is the canon's ports and adapters, reached from the picture. Proven: with the inset moved, both lenses and the board print byte for byte what they printed; and Markdown shows lenses that were written before it.

Rejected: Surface as the core word (it names each made thing, not what they share); layout kept in a lens's lines (the text surface's inset had leaked into every lens); a surface for each lens (a lens would not just work on a surface made later).

2026-11-12

The view one can open and move in is the fulldome on one more surface: ocoeco fulldome opens every lens in the terminal - the lenses on the left, what the chosen one brings into focus on the right, g for what can be glimpsed through it - for this place or every place under a root. It is not a lens and no lens knows of it. What was lab-agent's board is a lens focusing; a terminal is one surface that lays a focus out, plain text another.

The author, 2026-11-12: what was a board is now just lenses focusing - the same shining of stars, through a lens, into focus, laid out into a terminal view. A lens says what comes into focus; where it is laid out is the surface. So the terminal needed no design of its own for each lens, and the work and problems lenses showed in it as they stood.

Rejected: A lens for each surface (the same queries written again for every surface); a layout of its own for each lens in the terminal (a lens would stop just working on a surface made after it); a new name for the view (the fulldome is already the word for all lenses, touched not watched).

2026-11-12

The observatory's page shows the fulldome: after observing, ocoeco fulldome --observed data --surface html lays every lens out on the HTML and CSS surface, published beside the engine's site as fulldome.html. What was observed is a place a lens can focus on - a folder of tables whose every row names its project - so the acts follow each other as named: observe, then focus. The dome's port gains the fulldome: every lens together, each surface laying it out whole, and saying which lens brought nothing and why.

The engine's views are four thousand lines written by hand, one view at a time; a lens is declared once and shows on every surface. Publishing the fulldome beside them lets the two be compared before any view retires. Proven: the fulldome over the places on the lab's disk and over what the observatory observed show the same lines.

Rejected: Replacing the engine's site at once (nothing to compare against, and five lenses have no focus yet); a second way of gathering for the page (what was observed is already a place); cloning every star in the observatory's builder (observing already brought their data).

2026-11-12

The problems lens is the andon: a problem is raised by whoever sees it - what, where, when, by whom - and stays in view until its countermeasure is written; writing the countermeasure is what handles it (the computer supplies the day). It also reads the work, to show what has stalled for more than a week. A lens may read tables other lenses define (reads); a read of a table no lens defines stops the build.

The largest gap the research found (research the-fulldome-lens-by-lens): on 2026-11-12, 21 release runs failed unseen and a watcher stayed silent for a night. At Toyota the cord is pulled by whoever sees a problem, and the light stays on until there is a countermeasure; nothing is closed by being marked closed.

Rejected: Only derived problems (what a person notices has nowhere to go); only recorded ones (stalled work is already known from the data, and asking a person to copy it is the hand-work lenses end); a status to set by hand (a problem is handled when its countermeasure exists, so the countermeasure is what handles it); the hand-written check of what needs attention, kept apart (it is read here, from the same data).

2026-11-12

What a lens brings into focus, before any surface lays it out, is the projection: its parts, each line with what it is about and what it means. A projection looks at itself there, while it is still intelligible: each line has what it is about; the same thing is not shown twice in a part; a measure lies within its whole; a line names nothing its answers do not hold. What is not sound becomes a part of the projection itself - so every surface shows it, the voice says it and ocoeco check fails; never silently, and never as an exception no other program can use.

The author, 2026-11-12: what we have on different surfaces are results of projections, and while the data is intelligible in the form of a projection we can make a self check of what is being projected before it reaches the surface, not after it - as is often done in the world, resulting in an unmovable mess of regexes, text manipulations and reasonings in someone's head. On 2026-11-12 observed runs fed back into themselves, 45 shown as 135, and it was found by counting: this check finds it as it happens. Over every star, every place at once and what the observatory observed, every lens is sound.

Rejected: Checking a surface's text (what was structure is by then a pot of text); a test beside the program, run once (the world changes after the test passes); stopping with an error when not sound (the rest of the picture would vanish with it, and nothing could be done with the error); mending silently.

2026-11-12

What is worth saying is what newly came into view. Each line a lens brings into focus knows what it is about - its star and id when the answer names them - so ocoeco focus LENS --since FILE says only what is new in a headed part since last time, and what is no longer in view at all, keeping the focus for next time. A total is not news, nor a line whose words changed (an age) about the same thing; the first time only keeps. It works for any lens and over what was observed (--observed).

lab-agent's daemon pushed the whole board to the author's phone every few minutes; in OCO's shape the board is a lens, and a person needs what changed - an item taken up, a problem raised or handled - not the whole again. Built once for every lens rather than for the board.

Rejected: The whole board said again each time (noise that hides the change); comparing lines as text (every age and count would be news every day); a mechanism for the board alone (the problems lens needs the same).

2026-11-12

A part of a projection has a shape, and a chain is one: a lens says a part is a chain - from this value to that - and every surface walks it from where it begins, a line and then the lines that go on from where it arrives, each once, whatever order the rows were kept in. How far along looks is the surface's own: set in on text and on a screen, nested in Markdown, moved over on a page. And a line keeps its named values in the projection, not only its words - so a surface, a program or an agent reads what a line is made of (--surface json).

The red line of the route was first laid out as a list sorted by name: the connections were true and the order of the route was gone. The author had asked that it be seen that from x followed y, z and d, and from them g; and that an agent use the projection, before the pot, as its interface - which a line glued to text could not be. Setting aside lines that keep their values as a game of looks was wrong: it is what a chain and an agent both stand on. Lists are unchanged: four lenses print byte for byte what they printed.

Rejected: Ordering the rows in the query (the order of a walk is not an order of rows: one row may be reached two ways); a chain drawn by one surface (the next surface would not have it); a lens that sets its own indentation (looks in a lens).

2026-11-13

A lens can be entered like anything else, and kept by a place as rows: the lens of language takes a lens (what it says of itself, what it reads) and its parts (what each asks and how a line is laid out - or which lens it places, and under which heading). A place that keeps such rows has that lens: it is in view wherever the place is, held to what every lens is held to, and seen by the lens of language like any other. The rows carry a lens whole in what it says and what it brings into focus - every lens built into ocoeco, turned into rows and back, is the lens it was. A lens's own tables and entries are not yet carried by rows.

The author, 2026-11-13: we need a lens that shapes data so that a lens is the outcome - lenses defined as data - a lens that makes lenses. The lens of language could read lenses as rows and not make one; its own line said language - takes no entry. And the rows described a lens without being one: a part's row did not say whether it is always shown, its measure, its chain, or what it is laid out per.

Rejected: Rows that describe a lens and are not it (two forms that can disagree); a way of entering lenses apart from entries (a lens is entered like anything else); carrying a lens's own tables and entries by rows before the trial has shown what that asks (left, and said).

2026-11-13

A part of a lens may be what another lens brings into focus, placed there - all of it, or the part under one heading. It asks nothing itself: the other lens gathers, shapes and lays out. A lens made of such parts is a lens of lenses: a named arrangement that says only what to place together. Lenses placed in a ring are said, not followed. The work lens places the part of the lens of signs for what has not moved, and no longer asks the same.

The author, 2026-11-13: a lens of lenses does not care about the data that passes its shapes - where to get it, how to shape it and project it is done by those lenses; it shapes only which shapes to place together, and a sheet so made can itself be made into a word. It answered what could not be seen the day before - how a projection feeds another lens: by being placed. And it met a sign showing since that afternoon: the lens of language showed that signs and work each asked, in their own words, what has not moved for more than seven days, and there was no way for one lens to show another's part. The fulldome is such a lens with its arrangement written in code.

Rejected: The same query kept in two lenses (one changed, the other disagrees); a lens reading another lens's rows after they are laid out (the shape is intelligible before any surface); a new kind of thing for an arrangement (it is a lens).

2026-11-13

A milestone is reached when what it rests on is done, and that is read off the work, never typed: the purpose lens counts, for each milestone, how many of the backlog items its criteria name are done - a measure whose whole is the line's own (a measure may take its whole from the answer: whole = COLUMN). Criteria that are conditions told by tests are not judged by this lens, and it says how many. readiness is shown as what it is - a milestone's rung on the path, earned in order - not as how ready it is.

The author, 2026-11-13: a milestone is praise of a great work done, or of a great work ahead that fills a gap, merges overlaps or clarifies the whole; so far they were placed from our heads, out of taste - and the tool should show them, as intelligible data from intelligible data. Looking up what readiness meant found it had been misread for days: it is the rung (1 to 9; the specification: readiness is earned in order along the path), not a share done. The lens had drawn a rung as a filled bar, and a problem had been raised against Rhizoid for a milestone at 9 that was simply the ninth rung, rightly not reached.

Rejected: The rung drawn as a measure (a number shown as progress that is not progress); a share of readiness typed by hand (taste, not evidence); judging here what tests tell (the engine does, from the phone's own data; this lens says it does not).

2026-11-13

A place may bring its own lenses: lens files kept beside its mark, in lenses/, read as the program runs. They are found wherever that place is in view - by focus, the fulldome, the check - beside the lenses built into ocoeco, and held to what the build holds those to, said when they are looked through: no id used twice, no table defined by two lenses; one lens brought by several places is one lens. A lens a place keeps under a built-in one's id is that lens's own text - the built-in one is looked through, and the check says when the two no longer agree.

The author, 2026-11-13: what lenses do is left behind the brackets of an interface, in Rust code. Tried the same day with the lab's own record: oco-agent keeps a journal and beats in the language a lens declares tables in, and nothing could read them, because the set of lenses was whatever ocoeco was built with. Marked as a place bringing a lens made of its own declaration, what is being done now came into focus - to the minute, typed by nobody; the job that tried it saw itself.

Rejected: The lab's tables written into ocoeco's own lenses (ocoeco would know oco-agent); a lens that cannot be looked through until ocoeco is rebuilt (behind the brackets); a brought lens free of what built-in ones are held to (a table defined twice, met in use).

2026-11-13

The mark says what place this is beyond a star, and what it gathers: [place] is = constellation or observatory, gathers = stars as owner/repository or every star of an owner as owner/*. A mark that says nothing of it is a star's. So a star may be gathered by many places, and a place may gather a star that lives elsewhere. What a star is for - its kind - is another question and stays as it is. Standing in a place that gathers, ocoeco fulldome and focus show what it gathers: the same at every scale, with no flag. The four stars of kind lens, in the old sense, are the constellations: each already named its family in lens.toml, and ocoeco check holds the mark and that file in agreement while the file lives.

Everything else speaks of places, lenses and acts; the mark still said only kind and parent - nineteen of twenty-two stars with one parent, a flat list where there is a sky. Deferred on 2026-11-12 until the first lenses; there are seven, on four surfaces. Looking before replacing found that what a constellation gathers was already written down: lens.toml's family, owners and projects - many to many, as parent could not be.

Rejected: A new list beside lens.toml with nothing holding them together (they would drift); deriving the place from lens.toml alone (the mark would still not say what a place is, and that file is the old engine's); replacing kind (it answers another question); removing parent now (the engine's views still read it: it goes when they retire).

2026-11-13

A surface has two directions: it lays a projection out, and it reads back what someone gives there. A line typed in a shell is such a surface, and its reading back is argenv's own reader, as it is: what an entry may be given is handed to it as records made while the program runs - a field is an input, its allowed values the input's - and what was typed comes back as what was given, or as what could not be taken, said in the entry's words. ocoeco's own reading of typed words is retired. What an entry means stays with the lens: whether it is new or a change, what the computer supplies, which rows a field may point at.

The author, 2026-11-13: argenv is basically another lens - with the terminal as the surface it projects onto. Looked at against our own words it comes apart into two things already had: its declaration is what every lens carries, what can be entered; its reader, help and completions are the terminal as a surface - in the direction our surfaces lacked. One setting with two doors is one field coming back through two surfaces. Tried first with a throwaway program, then made: a misspelt field is answered with what was meant and a value outside a field's set is refused with the set, neither of which ocoeco's own reader did.

Rejected: A second way of declaring what can be entered, for the reader's sake (the lens already declares it); a build step making the reader's declarations (records are made as the program runs); keeping ocoeco's own reader beside argenv's (one nature, twice).

2026-11-13

An observatory is where one looks from: standing in one, what the machine itself holds is in view - the places its programs keep of themselves, found where programs keep their own data. They are not gathered, are named in no mark, and do not leave the machine; what is in view says so in words. A constellation shows what it gathers and no more.

The author, 2026-11-13: running continuously, it can treat its surroundings as part of the flow. oco-agent's record became a place bringing the lens of now, and was seen only by standing in its own folder: the author's observatory gathers what is discovered on GitHub, and the record is not there - nor should what the lab does be published. Where a thing lives and who can reach it from where: from where one looks, what is there is in view.

Rejected: Pushing the lab's record somewhere to be gathered (it is the lab's own, and the jobs it names are private); naming the machine in the observatory's mark (a public mark; and every other machine looked from would need its line); a link among the projects (someone would have to make it, and remember to).

2026-11-13

A place observes what its mark says it gathers, and itself - not whatever is found on a platform. constellation is a kind, for a place that is for nothing but gathering. ocoeco init --gathers writes what a place gathers into its mark from its first day, and refuses it for a star. A place whose mark names nothing gathered - the first observatory - observes all that is found, as before.

OCO is the ecosystem, not an observatory (2026-11-12-many-observatories): anyone may have one. Until now observing took every marked repository on GitHub - all of them the author's, so it showed nothing; the day another person marks one, an observatory would gather theirs unasked. The author's own observatory is next, in its own organization, tracking OCO as one constellation among his.

Rejected: Observing everything and filtering when showing (what was never asked for would still be fetched and kept); a list of places kept apart from the mark; making the first observatory name its stars now (it is untouched until its replacement stands).

2026-11-13

A connection is a row: this - how - that, with one line of why and how it is known (recorded, measured, read or reasoned), and the red line it belongs to. It runs between two particular rows of any tables, in any stars. Four kinds to begin with: led to, needed, halted, repeats. The lens of insight defines it, with an entry to draw one and a focus that lays each red line out. A reflection is what a red line is summed up in; it is not a second kind of prose. The projection itself is a surface (--surface json): its parts as structure, for a program or an agent to read before any pot.

The author, 2026-11-13: knowledge is kept as if it had value in itself, and research as dead gathering of facts, without their other side - insight: seeing connections where they were not seen, where things overlap, where there are gaps, how the whole fits together. A story written as prose is a pot that lost the relations it had one step before: that from x followed y, z and d, and from them g; what was a necessity, for what and of what kind; what was halted while it lacked. The retrospective of the same day had found that necessity has no link, and carried its chain in sentences.

Rejected: More relations declared on tables (a relation is for a whole table; a connection is found between two rows no schema foresaw); tables of their own for summaries, insights and stories (reflections already hold what was seen, learned and what it changes - they lacked something to stand on); a connection without how it is known (a reasoned red line must look reasoned, or the tidy story returns); a terminal as the only way in (reading the whole through it costs even an agent).

2026-11-13

A person makes an entry from the fulldome: on any lens, e opens a form for that lens's entries - the declaration ocoeco glimpse reads, described once. It asks only what a person is asked for; a field with set values is chosen with the arrows, not typed; what the computer supplies is shown as supplied; giving the id of a row that exists changes that row; a lens with several entries offers each. It is written the way every row is - guarded: one that would add a link to nowhere is refused, the reason shown in the form and what was typed kept. An entry is made only where one place is stood in, so it has somewhere to go.

The route, looked back over on 2026-11-13: lab-agent began as hands for a driver who had none, and gave the author a box to answer in on 10 November; the lenses that replaced its board could only be read - the one thing taken away and not given back. It halts the old daemon's retiring, and it is the first need of the route come round again (connections no-hands-no-switch and hands-again, in OCO's place).

Rejected: A form written by hand for each entry (the entry is already declared: fields, needed ones, set values, what is supplied); typing a status (a set value mistyped is a refusal that need not happen); writing from where many places are in view (the row would have no place of its own); a way of writing apart from the guarded one.

2026-11-13

ocoeco is released the way tad is: release-please keeps a release pull request open from the commits; merging it tags ocoeco-vX.Y.Z; and the package conveyor - called, not copied - builds the files for each kind of machine in the same run: a tarball, a .deb and an .rpm for x86_64 and aarch64, with their checksums and signed provenance. ocoeco keeps only what is its own: its declaration for the conveyor and its two build scripts. The first release is the first version that was ever released; 0.1.0 never was.

Until now ocoeco existed only as built from main on the lab: the tool at the centre of the commons could be on one machine, and a lens added there could be looked through nowhere else. The driver who works on the commons most looked at it for days by asking the lab to look. Tried the same day: handed the lab's own build privately, the driver elsewhere asked, waited and looked with the commons' own programs at once - but on a favour, and already one landing behind.

Rejected: A release path of ocoeco's own (tad's exists, and the conveyor is where everything around a build lives, once); handing builds over by hand (it worked as a trial, and rests on someone remembering); waiting for a first stable version to release (it is used daily, and changes daily).

2026-11-13

A row moves from one place to another with every link kept true: ocoeco move TABLE ID... --to PLACE rewrites each link to it - in the place it leaves, in the place it comes to, and with --root in every place held here - to where it now is, and its own links to what stays behind say which place that is. If anything would then point nowhere, nothing is moved and every file is as it was.

Places are being told apart - OCO a constellation, the author's observatory his own - and what was recorded in whichever star one stood in must find its home. A row is not only its line: nine later decisions refine the ones about the whole, words name them, reflections touch them. Moved by hand, each of those links would point nowhere. The first observatory's own records will need the same when it retires.

Rejected: Copying rows and leaving the old ones (two truths); moving by hand and mending what the check then finds (the links break first, and only the ones the check knows are found); refusing to move anything that is pointed at (nothing about the whole could then move).

2026-11-13

Text has two surfaces. Text that flows: continuous lines, wrapped as whatever shows them likes - it requires nothing and promises nothing of how it looks. And the screen: text as a volume of so many columns of monospaced characters, unwrapped (ocoeco focus or fulldome --surface screen --width N). Into it each shape is fitted by its own rule - a line's continuation sits under where it began, a bar is never broken, a word wider than a line is broken where the line ends - so no line reaches past the width, whatever the data. A surface says what it requires of whatever shows it, so that when it looks wrong it can be said why; and the screen looks at its own shape before a character is written, saying in itself if a line reaches past.

The author, 2026-11-13: when we constrain the volume - by how many monospaced characters fit in a line - text becomes a screen, and the shapes in a projection are tied to the surface they are projected onto; if an editor wraps or is not monospaced that is not the projection's concern - its concern is that these shapes, projected this way, give exactly this shape, and it can say exactly why it looks wrong: it defined the shape, the constraints, the borders, how the shapes lie together. Like a puzzle: the whole shape is defined first and the pieces carved in it, so they are guaranteed to come together. The bar of ten cells had assumed monospace without saying so; the terminal surface already carved one rectangle into others, and was tested at a stated volume both times. Proven over what was observed: at 100, 72 and 48 columns nothing reaches past the width, and the words are those of the flowing text, in the same order.

Rejected: One text surface that guesses a width (the requirement stays unsaid); cutting what does not fit (data lost to make a shape); leaving a too-long word to reach past (the guarantee would hold only for kind data); the terminal's library for plain text (a screen written to a file needs no terminal).

2026-11-13

A lens can be looked at as its beam: not what it brings into focus, but how light travels through it - what enters (each table it gathers, how many rows, from how many places); what each part lets pass (what it asks of, rows in and answers through, shown as how much of the light passes - or which lens it places, and how much of that comes through); and where it goes on to (the lenses that place it, the surfaces it is laid out on). It is a projection like any other: ocoeco focus LENS --beam, and in the fulldome b turns the lens in view into its beam and back.

The author, 2026-11-13: a lens of lenses that shows the relations of lenses, not the shapes they project - a line where information enters a lens, the lens's name, how its focus cuts off parts of the data, a line that continues into other lenses or down to a surface; and changing, a click away, between a projection and the beam it came by - so that everything is transparent, and the making of it too.

Rejected: A drawing of every lens at once (the beam of one lens is what can be read off and checked; the whole drawn later, from the same rows); counting what is cut off as rows in minus answers (a count that gathers is not a cut; how much passes is said as a measure); a view written apart from the surfaces (it is a projection, laid out by any).

2026-11-13

What is in progress on the board is read off the work, and no longer typed: an item that a record of work advanced lately, and that is not said to be done, is in progress - by whom, how often, when last, with its next step; one said to be done is finished lately. It is one question, laid out once for each. What is left for a person to say is intent: this is next, this is done, this is set aside. An item typed in progress that no work advances is shown as that - a sign, until the typed state is no longer set by anyone.

Decided that morning (states are read off the act) with the typed states left standing until the read-off ones had earned trust. In one day the typed board drifted twice under the hand that kept it, each time found only by reading it back to the author: three items in progress whose steps were done or halted; an item marked next that had been finished for hours. The seeing was already there, one part below the part that drifted. The author: correcting by hand a thing we decided should not be set by hand is itself a sign of a gap, and a gap is filled by clearer seeing, not by more handwork.

Rejected: Keeping the typed state as the headline (it drifted twice in a day); setting the state from the act when work is recorded (a state still stored, and able to go stale); two queries for in progress and finished (the same question, written twice - the lens of language would say so).

2026-11-13

The lenses themselves are rows, and a lens looks at them: the lens of language. Each lens in view - built into ocoeco or brought by a place - is read as data: the lens, each table it defines, each field, each entry it takes, each part it brings into focus, every row saying where its lens is kept. No place keeps these tables: ocoeco fills them from the lenses as they are, and a test holds what the lens declares equal to what the rows carry. What it brings into focus are signs, shown while true: a field declared again and again, the same line of a query written more than once, a table nothing brings into focus, a lens that takes nothing or brings nothing into focus. It shows; whoever sees merges - nothing here changes a lens.

The author, 2026-11-13: ocoeco looking at itself with its ecosystem can clarify itself, see what overlaps, which lenses handle the same nature and how they merge - healing, as against an unintelligible growth of lenses. Tried by hand first, with a search and guesses at how a query is spelled: half the counts came back broken or contradicting themselves. The lenses were the one thing in the commons still kept only as text a program reads - the language that makes everything else intelligible was not intelligible to itself.

Rejected: Counting the lenses' text with a search (it failed when tried); the lenses written out as files a place keeps (they would drift from the lenses, and need a step to remember); a tool that merges what overlaps by itself (it would hide what the lens shows).

2026-11-13

The lens of problems is the lens of signs. A sign is said by whoever sees it: what, where, and what kind - stale, overlapping, lacking, unclear. It is shown while nothing has come of it, and stops being shown when a connection leads from it to what was seen; nothing is asked about what was done. Many signs may lead to one thing, and then stop together. No table is added: what bears on what is a connection. The table keeps the name it was stored under, and rows written before are as they were written.

Decided on 2026-11-13 (what does not fit is a sign) and not done: for two days the lens went on saying countermeasure on every line, read past until it was shown to the author. Laid side by side from the data before reshaping: that one thing needs another is written five ways - an item serves, a milestone rests on, a connection, an item waits on, a countermeasure - and the last two are sentences nothing can follow: of eleven waits, one names a row; of seventeen countermeasures, none. A table of needs was about to be designed; a connection already is one.

Rejected: A table of needs (a sixth way of saying it); a field for what was done, as a link (a connection is that, and can be drawn from anywhere); renaming the stored table and its fields (rows in eight places rewritten for a name - a name is not the place it names).

2026-11-13

A projection is the topmost shape of shapes, and it is cut from the whole: fulldome, lens, part, line, place - each a shape taken from the one above. That each piece has exactly one place is guaranteed by its having been cut from there, not by rules about what a piece must be. A lens's line is such a cut: it divides a line into places, so what fills one can never land in another. A projection comes hand in hand with what it is projected onto, as a port with its adapters.

The author, 2026-11-13: this guarantee does not come from a set of rules. A puzzle starts as a whole; anyone can make one by cutting a picture into pieces, with no rules of what the individual shapes must be - the pieces are guaranteed to make the whole and their places are fixed, because it was a whole and each piece had exactly one place. Projection is just the topmost shape of shapes. This settles what was left open on 2026-11-13 (which of two nested shapes the word names): there are not two things.

Rejected: A guarantee from rules for each piece (joints) - the direction was backwards; two words for the shape of the data and the shape fitted to a volume (one whole, cut); checking after writing that nothing reaches past the width (a whole cut rightly cannot; a volume too small is a cut that cannot be made, and belongs at the cutting).

2026-11-13

A field's place in the order of its table is its ordinal, not at: at holds a moment everywhere else. Every built-in lens's rows and the rows OCO's place keeps say it so.

The lens of language's sharper question, asked the first time: at held integers in beats, journal and said (moments, in seconds), strings in glimpses and runs (moments, as text), and in lens_fields a place in order - named so that same day.

Rejected: position (a word the query language keeps for itself); seat, nth (less plain).

2026-11-14

Within one look a lens is brought into focus once: a lens that places parts of another is given the same bringing each time. What was brought is not kept beyond the look.

Sign a-look-is-slower-than-is-understood. Timed lens by lens on 2026-11-14: the author's sheet took 4.7 s where the lens of signs took 0.9 - it places three parts of signs, two of work, one of purpose, and each placed part brought the whole placed lens into focus anew. The same nature as the graph made twice, one level up; and it was found by measuring, after a prediction made without measuring had been off by a factor of three.

Rejected: Placing a part without bringing its lens (a part may ask of shapes its lens names; the lens is what is brought).

2026-11-14

A lens can be looked through from a thing - lens@thing - as an observatory is looked from somewhere: wherever the lens says {here}, the thing stood on. The lens of around does so: from one thing, what it points at and what points at it, each by how, with a few words of what each is; to step is to stand on a neighbour. What fits offers the things to stand on - the kind first, then the thing. Every thing in the graph says what it is in a few words. And the lens of the graph measures how far the work can be walked up: from a record of work to an item, to what the item serves, to a milestone that rests on it.

The author, 2026-11-14: what is most important is not the structure alone but navigating in it - between composition, concrete work answering concrete needs, and decomposition, moving back to see the plane one is on from the plane before - without losing the relations that were there in the details. Looked at first: no lens looked from one thing; each looked across a kind. And of 309 records of work, 198 reached an item, 93 what that item serves, 37 a milestone - relations thin out going up.

Rejected: A view of its own for walking (it is a lens, laid out by any surface, offered by what fits); naming the thing only in full (a star names its place where there is one of that name); directions - up, down - declared on relations before use has shown which way each points.

2026-11-14

A lens is kept by a place as rows, whole: what it says and reads, its tables with their fields in order, its relations, its entries with what the computer supplies, and its parts. The lens of language takes an entry for each - lens, table, field, entry, relation, part - and an entry is found among the lenses in view from the place it is entered in, built in or brought. So a place can make a new kind of data through entries alone, enter into it through the entry it made, and look through the lens it made; every lens built into ocoeco, as rows and back, is the lens it was.

The author, 2026-11-13: a lens that shapes data so that a lens is the outcome - lenses defined as data. A lens could be kept as rows since that day, but only one that places or asks: the rows did not carry a lens's tables, relations or entries, so a lens kept as rows could not define anything. Tried in a throwaway place: a lens of questions made through entries alone, a question entered through the entry it made, and seen through it.

Rejected: A table's declaration kept as one block of text in a row (the language would hold a piece of itself it cannot read); entries found only among the lenses built in (a lens a place makes could not be entered into); a place's tables added to its mark by an entry in the same step (what a place keeps is the place's own word).

2026-11-14

A place may say other names its tables are known by, in its mark: a name, and the table it names. A link written with any of them holds, and the graph names the row by the table's own name. And a relation may say that a link carries a level after a mark: a condition a milestone rests on (feature:voice-calls@linux-best, component:kernel@xiaomi-surya) is a link whose row is the feature or component and whose level is what follows @; one over every feature, or over no kind of row (tests@a-device), names no row and is not a link. The phone's docs say that feature and component are other names for features and components. So conditions are edges like any link: checked, walked, counted.

Sign a-condition-names-its-table-otherwise: 45 conditions were passed over, and the graph said nothing pointed at any feature while conditions did. The author: a name is not the place it names; many names may point at one place. Tried in a copy before anything landed: the first trial found conditions of three kinds - feature, component, and tests at a device - and stopped; set right, none pointed nowhere.

Rejected: Guessing a plural; rewriting the conditions another program reads; changing the relation that passes conditions over (the language grows: a second relation says what the first did not, and the first stands as it stood); a list of exceptions for what is not a link (a level said of no kind of row names no row).

2026-11-14

The lens of language asks which names hold different kinds of thing in different tables, where it listed every field declared more than twice: a name used again for the same kind is one word used rightly (id in every table); a name that holds a date string in one table and a number in another is where names collide.

Looked through on 2026-11-14: the list said 16 fields were declared again and again, id first, in 26 tables - mostly the same word used rightly; it could not tell a shared word from a collision, and so said nothing anyone could act on.

Rejected: Keeping both parts (the old one is the new one's noise); declaring each field once as a word shared by every table (a restructuring the look did not ask for).

2026-11-14

A part may name the shape it makes, and the other parts of the lens ask of it by that name, as of a table: the shapes a lens names are made ready in order before its parts are asked - when it is brought into focus, in its beam, and when its shape is checked. A named shape with no line of its own is not laid out: it is passed on through. Its name may not be a table's. The beam shows it as what it shapes, and the parts that ask of it as taking their light from it. Purpose shapes what each milestone rests on once, as rests, and both its parts ask of it.

Met from the side of the data (sign one-shape-asked-twice-in-purpose): what each milestone rests on was asked twice in the same words, and before that twice in words just different enough that the lens of language could not see it - because a part could not name a shape for another to ask of. It is the author's projection that feeds another lens, in its smallest form: within one lens.

Rejected: A shape kept in a place as a table (it would drift from what it shapes); asking a shape across lenses in the same step (within one lens first, where what it asks is plain); a shape laid out as well whether or not it has a line (a shape is light passed on, not a picture).

2026-11-14

A row entered through an entry is remembered as what the next record of work touched, as a row written by note is: a record of work says all it changed. And the work lens shows a next step said before the work that followed it - work recorded on an item after its next step was last said. Where it is not known when a step was last said, nothing is shown.

Sign a-next-step-typed-goes-stale. Looked at, 2026-11-14: only 12 of 332 items say a next step, and of 7 with work done after, five named a step already taken - the simplest lens a trial made that morning, read-off-the-act a step done two days before. And it could not yet be read off soundly: every one said last said, never - a record of work noted what it changed only for rows written with one command, not through entries, by which nearly everything is written.

Rejected: Dropping the next step (an intention is a person's to say); showing every step whose saying is not known as stale (not known is not stale); a date typed beside each step (another state to keep true).

2026-11-14

The part of the work lens showing a next step said before the work that followed it is taken back. Whether a step has been taken cannot be read off work recorded after it was said: working toward a step is not the step done. What stands of the day's change: a row entered through an entry is remembered as what the next record of work touched.

Within the hour it showed a step as passed that was exactly right: a route is a lens had its next step said at 19:39, and minutes later a record of work was made standing on it - a sign being entered - and the part showed it. It could not tell work toward a step from the step being done, and so showed on ordinary work.

Rejected: A number of records after which a step counts as passed (a rule in place of seeing); keeping it on the sheet as a prompt to look (the sheet is for what shows, not for what might). What would read it off: a next step that is a link to what is to be done, as waiting became a link to what halts - a change to what a next step is, not a query.

2026-11-14

Observing a part - only what has run - writes only that part's tables: the places found and what a whole observation found wrong are left as the whole observation wrote them.

Tried before one observer of runs was made of the author's observatory: observing only what has run into its data rewrote the places found and what the observation found wrong - the second to nothing - so a look at a part would have erased what a look at the whole had found.

Rejected: Merging what a part found wrong into what the whole found (which a part did not look at, it cannot say is gone).

2026-11-14

A projection is a plane, and a plane can hold planes. A lens placed whole is placed as its plane - its name, what it says, its own shapes - kept within the placing lens; one part of a lens placed is that shape among the placing lens's own. Every surface lays out a plane, planes within it included, the one way it knows; what is the surface's own is only its frame - a title, and for a page its style. The fulldome is a lens like any other: it places every lens in view, each keeping its own shape - so the fulldome's own kind, and each surface's second way of laying it out, are gone. Lenses stacked read a shape before any surface (a named shape, read across lenses); lenses side by side are placed in a plane. Every surface lays the fulldome out as before, line for line, but that the language now counts it as a lens.

The author, 2026-11-14: what we call a projection is a plane - all shapes of shapes in one plane - much easier to feed into another plane of lenses before it hits a surface, where the shape of the data is lost; a lens that places lenses side by side is a plane-lens (instances such as a fulldome of some stars), and lenses stacked one after another read the preceding plane and leave out what their focus does not pass. Looked at first: the plane was flat - placing a lens poured its parts into the placing lens, nothing keeping them together - so the fulldome had a kind of its own, and five surfaces each a second way of laying it out, 77 lines written because a plane could not hold a plane.

Rejected: Keeping the fulldome as its own kind beside lenses (a plane-lens written in code); flattening a placed lens (its shape of shapes lost); a lens reading another lens's lines as laid out (light bounced off a surface - stacking reads the shape before it).

2026-11-14

The graph follows the relations of every lens in view - those built into the program, and those a place brings: a relation is a relation whoever declares it.

The conversation, made a place on 2026-11-14 with its lens entered through entries: each of 2,881 turns says which it follows, the place's lens declares that relation - and the graph had none of those links, for it read relations only from the lenses built in. Standing on a turn showed nothing. The author: adjust ocoeco itself with how it can express all that, fit in the whole, discover itself in it.

Rejected: Declaring the conversation's relation in the program (the program would have to know of every place's kinds); leaving a place's relations to its own lens's queries (a link is a link in the one graph, or it cannot be walked).

2026-11-14

A lens may say a route: a table whose rows are not kept by a place but read from a kind of surface, where each place in view is held, when they are asked for - stored nowhere. A route is part of the language like a relation or an entry: a row, entered through an entry, shown by the lens of language. The kinds of surface are few, each a small adapter in the program; the first is git history - each change to a place's repository, its name, when, by whom, what it says of itself. What the lenses in view keep out is kept out of what a route reads, as it is read. The beam says from which surface the rows were read, and when.

The author, 2026-11-14: a lens takes the shape of data from a surface and lays it on another; the lens behind does not care where the shape came from; what is called a place is how to get to it and what it has, and the lenses themselves show how to get there. Looked at then: five ways in, all written in the program, and of ten surfaces not yet read most lacked one thing - a route. Others who read a surface as a table (research reading-a-surface-as-a-table) say the shape as data, keep the kinds of surface as a few adapters, and say beside the shape which surface is read. Tried: a place made a lens with a route through entries alone - no Rust, no file edited - and looked through its own history.

Rejected: A route that runs what it is told to (a lens takes a shape from what is; it does not act); rows read from a surface copied into a file of the place (a second copy, as of some moment nobody says); the history read by the program for every place whether or not a lens asks (what is read is said by a lens, or it is not seen to be read).

2026-11-14

How a place is got to is a route, and a route says as of when: a folder with a mark is held here, as it is now; what an observatory observed is as of when it observed; what the machine keeps is as of when it was last written; what the program makes from the lenses or the links is made now. A lens's beam says of each table by which route its rows came, and as of when.

The author, 2026-11-14: what is called a place is not so much something fixed - it is how to get to it and how to get what it has; lenses can do that, and themselves show how to get there. Looked at first: the program has five ways in, and three of them said nothing of as of when - yet routes differ in exactly that, and showing what was observed as if it were so now is how the false alarms about failing runs began.

Rejected: A place taken to be its route (the same place reached two ways would be two places: a place is what its mark says it is, the same along every route); the routes rebuilt as lenses in one step (looked at and said first; what the beam shows decides what follows).

2026-11-14

A row written is held to its table's declaration as the place speaks the language: the lenses built into ocoeco, and the lenses the place brings - as files or kept as rows. A table a place's own lens defines is checked as any other; a value is written as the kind its field declares.

Sign a-row-is-checked-only-against-the-built-in-lenses: only the built-in lenses were the declaration a row is held to, so a lens made through entries would have taken any word for any field.

Rejected: A declaration made once for every place (each place speaks the language with its own lenses too); a place's lenses free of the declaration (a lens that defines a table says what its rows are).

2026-11-14

A route may say which of what its surface holds, and the shape carved from each. Of the kind files: which names the paths within the place - any folders, any name - and where no shape is said each file is a row; where one is, every place in a file the shape is found is a row, what the shape names being its fields, with the path and the line. A place reads its own files. So the source a place holds and the guards written for it are two routes of one kind, said in the language - the lens of the program - and not an adapter each.

The author, 2026-11-14: a chunk of data is a shape of shapes; a lens can take any shape in and carve shapes within it - from a file its first line, its upper left ten by ten, its middle - and compositions of lenses carve any subshape from a shape. After the first route, each surface still unread looked like another adapter to write: one for guards, one for source, one for what is said to run. Stepping back, most are files in a place's own repository, differing only in which files and which shape is taken.

Rejected: An adapter for each kind of thing found in files (the kinds would grow without end, in the program); files read beyond the place's own folder (a place is read where it is; what is elsewhere is another place's).

2026-11-14

A step is an item that serves an item: what an item serves may be a milestone, a decision - or another item. So what an item rests on next is read off - the items that serve it and are not yet done - and a step taken is seen taken. An item's next step as words stays what it is, an intention. And a relation as it stood is still there where one of the same field points at all it pointed at: a relation may gain what it points at, as a table may gain fields.

Sign a-next-step-is-words: whether a step said in words has been taken cannot be read off; were it a link to what is to be done, it could. Looked at: an item already says what it serves, and what serves a thing is what it rests on, read from the other side - nothing new was needed but that an item may serve an item. The guard on relations held them exactly as they stood, as the guard on tables had.

Rejected: A field for the next step as a link (a second way of saying what an item rests on); a kind of row for steps (a step is work like any other, and may have steps of its own).

2026-11-14

A surface is said by a lens. What a lens brings into focus is a plane, and the program makes it into rows in the order it is laid out - a lens placed within it by its name and what it says, a heading, each line with how far along it is, its measure of a whole, what it is about. A lens that reads the plane lays it out: it is looked through from the lens whose plane it is - surface@lens - and asked for as any surface is. The first is as-text: the text surface the program has always had, said in the language. A place says a surface of its own the same way, through entries. What fits offers them; the fulldome does not place them; the dome does not list them.

The author: a surface is an abstraction, and a concrete surface can be any implementation of that abstraction in a lens; lenses compose to project onto any surface and to observe from any surface. Observing from a surface was said by a lens since the route; projecting onto one was the program's alone - every page, digest or message more program. Measured over every place in view, 2026-11-14: eighteen lenses, and the whole dome of 1,014 lines, laid out by the program's text surface and by the lens - the same, byte for byte.

Rejected: A surface as a template of its own kind (a second language beside the lens); retiring the program's text surface at once (it is what the lens is held equal to: it goes when nothing asks for it); a surface as one more part of the whole (it lays a plane out, it is not a part of one).

2026-11-15

A table a place keeps is entered as itself where no entry has its name and none fills it - the identity's second face: it asks every field the table is declared to have, offers and holds a link as any entry does, and writes the row. And what a table is, is said once, found in this order: by the lens that defines it; else by the place that keeps it, in a declaration of its own (tables.toml); else as its rows show. A row is held to that shape as it is written.

Sign a-shape-said-where-entries-do-not-read: four places - the playbook, the canon, the git-rhizoid site, the phone's docs - say the shape of 40 tables in a declaration of their own, which the ecosystem's entries did not read; a field on such a row was written with note, past the entries, and what the canon's own check refused in CI nothing refused at entry. And the identity had one face: a table was looked through as itself, and entered only if a lens gave it an entry. The lens laws name both: get and put.

Rejected: Declaring such a table a second time in a lens (two sayings of one shape, to keep in step); an entry written for each table before a row of it can be entered (the ecosystem would take in only what was prepared for it); entering as itself a table an entry already fills (two ways to write one kind of row, one of them missing what the computer supplies).

2026-11-14

In the dome in a terminal one walks: right begins it - the things named in what is shown are found, and the first pointed at; down and up point at another; right stands on the one pointed at, and what is shown is the lens of around from it; left steps back to where one stood before; escape ends the walk, and only then leaves the dome. A line names the first thing it speaks of - whole, or with the table left out where that names one thing only. Where one stands is said, and standing on a thing there is a step on the driver's trail as it is from a shell.

The author, 2026-11-14: what is most important is not the structure alone but navigating in it - between composing and stepping back, without losing the relations; and an interactive, self-speaking interface for it is on our periphery, which the system allows. One could walk by typing a lens from a thing in a shell; the dome, which stays open, showed a lens and could go no further.

Rejected: A view of its own for walking (it is the lens of around, looked through from the thing: the dome only chooses where to stand); lines made to carry their thing's name unseen (what a line says is what names the thing: a line that names nothing cannot be stood on, and that is seen).

2026-11-14

What lies ahead is read off what holds things back: followed as far as halts lead, the work that would free the most once done is shown first, with what it would free. The purpose lens asks of the work lens's shape of what holds each item back - one place knows the halts; the purpose of the whole reads them.

The board's item milestones-read-off-the-data: a milestone is praise of work done, or of work ahead that fills a gap; placed from our heads, out of taste, until the tool shows them as intelligible data from intelligible data. With waiting read off what halts it, the halts are there to follow.

Rejected: A ranking typed by hand (taste); the halts asked again in the purpose lens (one shape, read across lenses); only the first step of a halt (what is freed once one thing is done reaches as far as the halts lead).

2026-11-14

A table no lens declares is looked through as itself too: what a place keeps is in view whether or not the language has a word for it, its shape read off the rows that exist - keyed by id; each field a whole number, a number or yes or no where every value of it is so, otherwise words.

Looking at the whole, 2026-11-14: asked to look through practices as itself, ocoeco showed nothing - the graph counts 39 of them as things, and no lens declares that table; so too principles, architectures, components, features, translations. Places keep them; the language has no word for them; they could not be looked at at all.

Rejected: A lens written for each such table before it can be seen (the ecosystem would consume only what was prepared for it); guessing a shape from the first row (every row is read).

2026-11-14

Every command of ocoeco speaks from a blank, not only entries: what fits reads the program's own declaration of each command - its flags, whether each takes a value, its positionals - and offers the next positional and the flags not yet given; where a value's name is one the language or the program knows - a lens, a surface, a table this place keeps - it offers what that may be. Nothing is listed by hand: the declaration is read.

The purpose lens, asked what would free the most once done, named ocoeco on argenv - six items, the whole switch the author's own driving waits on; its next step is the way in speaking for itself, which the author set before the form. In the shell only entries spoke; the program's own commands offered nothing, though their declarations say what they take.

Rejected: A list of each command's options written for the shell (the declaration is the list); offering what a value may be by guessing from its type (only what the language or the program says).

2026-11-14

A place that says what it gathers finds it, when it observes, by asking for it - every repository of an owner it names whole, each star it names, and itself - and takes what carries a mark. A repository with no mark is not a place and is passed over without a word. No label on a repository, and no search.

Sign a-place-is-said-twice-to-be-one: the conversation, made a place under an owner the author's observatory gathers, was not observed - places were found by a label put on a repository by hand, through GitHub's search, which lags behind what exists; and what the mark says it gathers was used only to filter what the search found. Two things said a place was one; and a route did not say as of when.

Rejected: Setting the label when a place is made (the second saying, kept in step by a program); searching for the mark's file (the same index, lagging the same way).

2026-11-14

What holds an item back is read off what halts it, not typed: a connection says this halted that, and the halt holds while what halts is not done - an item not done or dropped, a sign nothing has come of - unless a connection says the halt ended. The work lens shows what is held back and by what, and what is said to be waiting though nothing drawn holds it back. A connection may now say that something ended a halt: said of the halt itself, so the halt stays in the record and is no longer in force.

The board's own next step for reading off the act: waiting read off what halts it. Looked at first: of twelve items typed waiting, eleven said what they wait on in a sentence - nine naming a row - and eight halts were drawn, one of them over: argenv's open lists halted ocoeco on argenv, and the trial showed it did not wait after all, with nothing to say so (a halt is a state, and it was typed).

Rejected: A waits_on field that holds a link (one more place saying what a connection says); the halt removed when it is over (what was is the record); the typed waiting taken away now (it stands beside what is read off until the reading earns trust - the part that shows them apart is how it does).

2026-11-14

A table a place keeps on another branch of its own repository is kept by it all the same: where the place is held, it is read there with git, and it is as of when that branch last changed - which the beam says. Its rows are things like any other.

Looked at on 2026-11-14: 18 places keep their activity, what CI did and their releases on another branch, written nightly; they were read only by observing, and passed over in three places in the program where a place is held. The mark already said the route - a path, and a branch; nothing read it.

Rejected: Leaving them to observation (the same place seen two ways would differ in what it has); copying them into the folder (a second copy to keep in step).

2026-11-14

The lenses a place keeps as rows are brought from what an observatory observed as from a folder with a mark: by whatever route its rows arrived, a place has the lenses it keeps. So an observatory's sheet is in view on its published page, as it is where the observatory is held.

From what was observed the author's sheet was not in view at all: its rows were there, observed, and lenses were brought only from folders with a mark. Tried in a copy observed anew: the sheet from what was observed is the sheet looked at live, line for line.

Rejected: Bringing lens files from what was observed (what is observed is rows; a lens kept as rows is what travels).

2026-11-14

The parts that took a written link apart to find what it points at read the graph instead: an edge says each of its ends as parts - where it is held, its star, its table, its id, and the connection it came through - and a lens joins on them. Six parts moved: in work, what was done and what nothing advances; in signs, what is showing and what came of it; in purpose, what a milestone rests on, twice. Over every place each of the three lenses shows what it showed before, line for line. What tests tell of a milestone is still counted as it is written: a condition is not yet an edge.

The trial of the graph (2026-11-14-the-graph-under-the-tables) showed the links are all there as edges; what it had not done was let other lenses use them. Of 36 parts, 6 took a link apart with splitting, cutting and matching inside text; the others that rewrite a name only shorten it for showing. Proven by the strongest test there is: what a person sees is unchanged.

Rejected: Moving the parts and judging the difference by eye (each lens compared line for line before and after); keeping both ways side by side (one meaning in two places); making a condition told by tests an edge in the same step (what it points at - a feature at a level - asks its own look).

2026-11-14

An observatory may observe by holding: each place it gathers that carries a mark is brought to hand with git, as it is on GitHub now, and read there as any place held is read - its tables, those it keeps on another branch, and what the routes read. What is observed is then what is held, as of when it was brought: one way of reading, not two. And what a route reads - a commit, a guard, a file of source - is a thing in the graph like any other, named by what it names of itself and not by the line it stands on, and is observed with the rest; the places are read side by side. A record of work was made standing on what is there when it is made.

Sign what-a-route-reads-is-not-a-thing: a route was read only where a place is held, so a published page - built from what was observed by asking GitHub - had no history, no source, no guards; and one could not stand on a guard. Looked at: observing already had two ways of reading, asking GitHub and reading folders under a root, and the second read a table kept on another branch from the wrong place. Tried on the lab: observed from held folders and by asking, 43 of 44 tables were the same byte for byte - the other differing by one run that happened between - and holding gave 1,703 changes, 532 guards and 126 files besides.

Rejected: Teaching the way that asks GitHub to read each route through its own calls (every route written twice, forever); bringing everything a gathered owner has (the first trial brought a fork of the Linux kernel - 4.2 GB, six minutes; only what carries a mark is a place, and those are 26 MB and a minute and a half); copying what a route reads into the place's own files (a second copy, as of nobody knows when).

2026-11-14

A row belongs to the place it is of: the place it names - its project - where that place is in view, else the place that keeps it. The same row reached by more than one route - observed by two observatories; held here and observed - is one row: the one whose own moment is the latest, and where it says none, the one that came first. The ways in say so once, and both a lens's gathering and the graph read rows through them.

Sign a-run-in-view-twice: looked at live from the author's observatory there were 98 rows for 49 runs - two observatories each keep what they observed of what has run, and both are in view - and one of the two was a day older: a run as it was on the 13th beside the same run as it is on the 14th, both as if so now. Had the older failed and the newer passed, the lens of signs would have shown a failure that is no more. The author: a place is not its route; and a route must not hide as of when.

Rejected: Leaving one observatory's observation out of view by a rule (which is the fresher is said by each row, not by a list); naming such a row by its keeper (it is about the place it names: its keeper only observed it).

2026-11-14

A part that puts another lens's plane or shape beside this lens's own says places; through is left to light passing a focus - the beam's rows in, so many through. Side by side and one after another, the two ways lenses go together, each have their own word. Every built-in lens and the rows the author's observatory keeps say it so.

Sign through-is-two-things, seen in the review the author asked for: one word for two natures.

Rejected: Reading both words for one field (a name is not the place - but two names in the program for one field is the overlap kept); leaving the beam's word to change instead (through is what light does).

2026-11-14

A repeat is asked as what it is: not a line but a group. The lens of the graph keeps repeats out of the longest line of one kind, and shows instead what repeats joins - every thing reached through repeats, whichever way, as faces of one nature.

Sign repeats-walked-as-a-line: walked as a line, repeats came back to where it began - argenv's open lists repeat ocoeco on argenv, which repeat argenv's open lists. A repeat says two things are one need with different faces (2026-11-13-a-need-for-clarity); the author: where two separate things turn out to be of the same nature they merge as one with different faces.

Rejected: Leaving repeats in the walk and capping it (a ring counted as a length); keeping a direction on a repeat (the first written is not the first in nature).

2026-11-14

A lens may read a shape another lens names, as it reads a table another lens defines: it takes its light from that lens - its tables, what it reads, and its shapes, made ready before its own, followed as far as shapes lead. One lens names a shape and others read it; a shape named by two lenses, or named like a table, stops the build. The beam says such a shape as light coming in, shaped by the lens that names it. The lens of the graph names what points nowhere, and no longer shows it; the lens of signs asks of it, as a sign read off the graph.

The named shape (2026-11-14-a-named-shape) let a projection feed a lens within one lens; the author's picture is light passing from one lens into the next. And what points nowhere was the graph's to know and the lens of signs' to say: both needed it, and only placing could pass between lenses - which lays out, and cannot be asked of.

Rejected: A shape copied into each lens that needs it (one meaning in two places); a lens reading another lens's projection as laid out (the shape is intelligible before any surface); shapes free of the rules tables keep (two of one name, met in use).

2026-11-14

The work lens shows where the work is happening - the things stood on while records of work were made in the last day, of any kind - and an item stood on while work was recorded is in progress, as one a record says it advances. What a driver does is seen where it is done; nothing is typed to place it.

The first record of work made the truer way said where it was made and nothing of what it advances, and so would not have shown on the board, which read in progress only from what was typed. The author: work is seen when it happens, through ocoeco.

Rejected: Typing what a record advances so the board shows it (the form-filling the act replaces); a board of items only (work happens on a decision, a thought, a sign as well).

2026-11-14

What points nowhere is known in one place, the graph: the check, the guard that refuses a write adding a link to nowhere, and moving rows all read it, as the lens of signs does through the graph's shape. The graph gives the edges of one place, followed into the others; an edge keeps the link as it was written, and for a connection whether its near end holds too. The program's own walk over every relation and row, apart from the graph, is gone. The check says what it said before, word for word.

Sign what-points-nowhere-is-asked-twice: when the graph came it said the same as the check - two places knowing one thing; with shapes across lenses the lens of signs read it from the graph, and the check still knew it on its own. Tried in two copies of OCO's place - one link made to point nowhere, and one connection's near end - before and after: the same words.

Rejected: The check bringing a lens into focus to learn it (it would ask the engine once for every place, where the graph is read in the program in a moment); a check that says it in new words (the words it said are what people and the jobs read).

2026-11-14

The graph is made of the places in view by whatever route what they keep arrived: a folder with a mark, or what an observatory observed of a place, each row naming the place it is of. What is observed carries what a mark says of its place - the other names its tables go by, what kind of place it is, what it gathers - so that what was observed says it as the place itself does.

The beam, the first time it said by which route its light came: from what the author's observatory observed - as its published page is built - the links were 0 and the shape of what holds things back was empty. The graph was made only of folders with a mark; so everything read off it - what holds things back, what each sign waits on, what lies ahead, where the work is happening - showed nothing on the page. The author: a lens behind does not care where a shape came from; it cares about the shape.

Rejected: A second way of making the graph for what was observed (one graph, made of places however they came); leaving what a mark says out of what is observed (the conditions milestones rest on would point nowhere on the page).

2026-11-14

Within one look the graph of the places in view is made once, and given to every lens and every table of it that asks: a lens brought into focus with all it places, its beam, a place checked - each is one look, and a look within another is the same look. Nothing is kept beyond it: what stays open, like the dome in a terminal, sees what has changed.

Measured on 2026-11-14, after the language, what the routes read and the tables kept on other branches had each become things: a look through signs took 1.2 s, the check of one place 4.7 s - and git, asked for a table or a history, a hundredth of a second or less. One graph took under half a second; it was being made again for each table of it a lens asked of, and by the check for every lens in turn. Every job checks all 25 places: jobs outran the wait for them three times that day.

Rejected: A smaller graph (what was added is what one stands on); the graph kept from one run to the next (it would show what was, as if it were so now - the thing answered all week).

2026-11-14

Every link in the commons is read as one relation - this, how, that - and looked at through a lens. Every row of every place in view is a thing, named by where it is held, its table and its id; every link a row holds in a declared relation is an edge named by its field; every connection is an edge named by how it bears, through the connection that says so. Whether an edge holds is said where the place it points into is in view, and left unsaid where it is not. No place keeps these rows: ocoeco makes them from the links, as it makes the language's from the lenses. The lens of the graph asks what rows alone could not: what is pointed at most, what nothing points at, how things point, and how far a line of one kind runs - the walk done by the engine, not by the program.

The author, 2026-11-13: tables are a particular shape of data, exactly like a lens - why pass everything through a middle man? Researched the same day (research tables-or-a-graph): at rest we already keep things with ids and links between them - nodes and edges, written as text; the tables appear only when a lens asks. Of 36 parts in the lenses, 8 take a name apart to find what it points at, and 280 lines of the program check links, 473 rewrite them, 59 walk a chain. A trial, not a move: it lets the commons see whether the graph is already there.

Rejected: Leaving the files behind for a graph store now (decided in a head, before the trial); a graph kept by a place (it would drift from the links it describes); naming a thing by its table and id alone (stars of one name live under several owners - lens is four).

2026-11-14

A table is looked through as itself where no lens has its name: every row passed through, each field as it is - the identity, the passthrough lens over what a place keeps, with no file. And the lens of language shows where a lens's two faces do not meet: an entry that puts into a table none of the lens's own parts asks of - what is put and not then got by the same lens.

Research the-simplest-lens: the smallest whole set of lenses has the identity, three ways into a shape, two ways together and two directions held to a law - what is put is what is then got. ocoeco had both ways together; it lacked the identity - a table kept as another kind of thing than a lens, though it is the passthrough - and the law between glimpse and focus was nowhere said.

Rejected: A lens file for each table (the identity declares nothing); the identity listed among lenses in the fulldome (one per table, filling every plane); enforcing the law as a refusal (shown, as a sign is, while it is so).

2026-11-14

The language is in the graph: every lens in view and what it is made of - its tables and their fields, its entries, its relations, its parts - are things; and how they go together are links - a part is part of its lens, rests on the tables and the shapes it asks of, and places another lens; an entry is for the table it fills; a lens rests on what it reads. One stands on a lens, a part or a table as on anything, and walks from what is laid out back to all it was made of. And standing on a star shows why it exists, in its own words: the rows of its idea.

Signs a-lens-is-not-a-thing and a-star-s-idea-is-not-reached, from looking at the whole on 2026-11-14: one could stand on anything but a lens built into the program, and only the lens of language saw the lenses, as rows of its own; and a star's idea - 95 rows across the stars - was pointed at by nothing, a walk arriving at the one line of its mark. The author: when a projection is not what we want, we navigate everything - how lenses compose, how shapes come together into a shape of shapes - from what we see on a surface back to anything that was before it.

Rejected: A lens of its own for walking the language (the graph is one; the language is in it); a link from every row to its lens (a row is of a table; its table is part of a lens).

2026-11-14

The lenses built into ocoeco are kept in language/: the shared language, built into the program. lenses/ is where any place keeps the lenses it brings. ocoeco's repository is still both the program's source and a place - but its source is no longer read as a place's lenses, so a lens file left there by work in hand is not laid out by the installed program as if the place had brought it.

Sign the-program-and-a-place-at-once, met three times: when the lens of signs was landed (the program installed and the place disagreed), and when a lens file left by a failed attempt was laid out by the installed program as ocoeco's place's own. One folder, two natures: the program's language and a place's lenses shared a name. The program itself already called these lenses the shared language.

Rejected: A place's lenses read from somewhere a mark names (a setting for what one name can settle); ocoeco's place left unmarked (it is a place: it keeps decisions and work); keeping the folder and skipping ocoeco's own place by its id (a rule for one place).

2026-11-14

The lens of the graph shows one line of each kind: the longest, and of those equally long the first by where it begins and ends. Where it begins and where it ends are of the same line.

Sign the-longest-line-is-not-settled: where many lines were equally long the lens showed a different one each look. Looked at: it took where the longest began and where it ended each on its own, so that among equals the two could be of different lines - a line shown that does not exist.

Rejected: Showing every line that is longest (hundreds, among the turns of the conversation); leaving it, as only a comparison had noticed (a lens that answers differently each time cannot be compared with itself).

2026-11-14

A relation says the nature of its pointing, where its field's name is one word among several for it: what a thing rests on (a milestone's criteria; a decision's research and sources; research's sources; a word's decision), what it is for (what an item or a working serves; what a record of work advances), what it follows (what a decision refines; what a reflection answers), what it is about (what a record or a reflection touches; where a record was made or a sign seen; what a decision is about). An edge carries it; a connection's how is its nature already. Standing on a thing shows the natures, as sentences - this rests on that; that is for this - and the graph shows the seventeen words as the few natures they are.

The author, 2026-11-14: look at the whole - how everything relates, what overlaps, what is behind it where there is less friction; and before: navigation between composing and stepping back, without losing relations. Looked at through the graph: seventeen words for how one thing points at another, among them four for what a thing rests on, two for what it is for, two for what it follows and three for what it is about - and nothing saying so. What it rests on and what it is for are the way down and the way up.

Rejected: Renaming the fields to one word each (the language grows and does not rewrite what it said; and each word is right where it stands); directions declared as up and down (what a thing rests on and what it is for say it in plain words); a list of which word is which nature kept in a query (the lens that declares the relation says it).

2026-11-14

Every place is a thing in the graph, saying what it is for; and what a place gathers - a constellation its stars, an observatory what it looks at - is drawn from it, as its mark says. The lens of around shows where a thing is held, and from a place what it holds by kind and the milestones it reaches for. So a walk from one record of work arrives at the whole: the item it advances, the milestone that rests on it, the star that holds it and what that star is for, the constellation and the observatory that gather it.

Looked at through around, the day it was made: a walk could not reach the top - a star's purpose is said in its mark, not in a row, so nothing arrived at what the whole star is for; and what gathers what was said in marks and drawn nowhere. The author: a whole is as far back as we can go, and navigation back must not lose the relations.

Rejected: An edge from every row to the place that holds it (three thousand edges saying what each thing's name already says); a table of places kept by a place (a mark is where a place says what it is; the graph reads it).

2026-11-14

A record of work says it touched the rows remembered since the last record that are there when it is made. A row entered and then put back - a trial thrown away, a change refused - was not touched by this record.

The same day entries began to be remembered as what a record touched, two refused attempts in the canon's place left such memories of rows no longer there; the next record said it had touched them, and the reader refused it for links pointing nowhere - rightly.

Rejected: Clearing what is remembered by hand after a refusal (handwork, and forgotten the next time); forgetting on every refusal (what is remembered and still there was touched).

2026-11-14

What a run's ending means, and that a failing one is urgent, is the lens of signs' to say, in one place: its part failing on main is marked urgent, and what newly comes into view there is said so. The voice carries what a lens says is new - urgently where the lens says so - and decides nothing. Observing only observes: the program's own deciding of what fails, and its saying of what changed, are gone. What is no longer in view is said as the line it was, under its heading.

Sign what-fails-is-decided-twice: what a run's ending means was decided by the lens's query and by the program's own code, and within an hour of one being corrected the lab told the author urgently of two failures that were not; a third thing - the voice - said nearly the same. Urgency was the one thing the voice could not know, and it is meaning: so it belongs in the lens.

Rejected: Keeping the program's own list of what fails beside the lens (the two disagreed within an hour); urgency decided in the voice's script (a meaning kept outside the lens); a third observer of runs kept quiet by a rule (left as it is: two observations, of the lab and of GitHub, now say the same way).

2026-11-14

The lens of language asks what a value is - words, a whole number, a number, yes or no - not what its type is called: a date is words held to a shape, as an id may be held to a pattern, and is not another nature than words.

Sign a-date-held-two-ways: date was declared a date in reflections and words in decisions and research - all three as the language stood on its first day, so none may be rewritten. Looked at: the two are not two natures. A moment kept as a number of seconds beside a moment kept as words is; and the lens asked about the name of a type, where it should ask what a value is.

Rejected: Rewriting what the language said to make the kinds match (it grows; what it said stands); leaving the lens to list a date beside a moment kept as a number (one is a shape held, the other a different nature).

2026-11-14

What an observation could not read is a sign - it does not fit, and the observation is who saw it. It is written among the signs the places keep, said by the observation and of the place it is about; it shows where signs show, and is gone by itself once the thing reads again.

Sign what-could-not-be-read-is-overwritten: observing wrote what it could not read to a file of the same name as the table of signs, and the table then overwrote it - the observation said 3 problems and nothing kept what they were. Two things under one name, and they were one nature: something that does not fit, said by whoever sees it.

Rejected: Another file for what could not be read (a second kind beside the signs, and a second place to look); leaving it to the line the observation prints (gone when the run's log is).

2026-11-14

What each sign showing waits on is read off the halts drawn to it: the shape of what holds things back holds signs as well as items, saying which it holds; the lens of signs asks of it, and says for each sign what holds it back, or that nothing drawn does and it can be taken up now. What nothing has come of is shaped once in the lens of signs, and both its parts ask of it.

The author, 2026-11-14: why keep using prose instead of ocoeco - if something is lacking that you want to reflect, the whole point of the ecosystem is to capture and reflect it with lenses composed for it. What was lacking was what each sign waits on: it was said in words beside a sheet that could not say it, and the words were wrong - one item waits on the token, not two.

Rejected: Saying it in a summary (it drifts from the data, and did); a field on a sign for what it waits on (a halt is what says that, from anywhere).

2026-11-14

What fits for a link reaches every star in view - every place kept beside the one stood in - not only the rows of this place: from a blank it offers this place's rows and the stars to go into; typing a star narrows to its kinds of row, then to its rows, each stroke choosing what fits the next blank.

Sign what-fits-knows-only-the-place-stood-in: twice in one hour a link into another star was typed from memory and refused by the guard - a decision in OCO's place written from ocoeco. The author: each stroke choosing what fits the next blank; being on a blank showing what can be entered.

Rejected: Offering every row of every star at once (thousands, and no shape to choose by); a link into another star written by its short name (stars of one name live under several owners).

2026-11-14

From a blank on a typed line, what may come next is read off the language and the rows that exist - a lens asked the other way: the commands; the entries; an entry's fields not yet given, saying which are needed and which hold one of a set; for a field held to a set, the set; for the id, the rows a change would be made to; for a link, the kinds of row it may point into that hold any, then the rows that exist there, each with a few words of what it is; for free words, nothing. ocoeco fits answers a person, and with --shell answers a shell as it asks (complete -C 'ocoeco fits --shell' ocoeco). Nothing is written apart from the language: it is read.

Waited on all week: the author's picture of entering - each relation selected, not entered; each stroke choosing what fits the next blank; being on a blank showing what can be entered. And the sign met three times in three days: an id typed from memory and refused. Everything it reads now exists: what each entry asks (entries), the values a field allows, which tables a link may point into (relations), the rows that exist.

Rejected: Completions written for each shell from a list (the list is the language, and it changes); a word for where values come from, added to argenv's contract (what an entry and a relation already say); offering every row of every kind at once for a link that may point anywhere (the kind first, then the row).

2026-11-14

Any lens may say what it keeps out of a place - a token, a key, a private channel, an address - told by its shape, and what of that shape is let be. It is kept out as a row is written, in the one function every row is written through: the words around it stay, and what was kept out is named where it stood. The program makes rows of it - where something was kept out, and where one is showing in what a place keeps - and the lens of what is kept out shows them. The check that runs before a change lands says where one is showing.

The author, 2026-11-14: no need for boundaries when everything is transparent and traversable; it was all one need - for clarity. And of the gap named in answer - that clarity works when someone looks; a secret is a surface too; what stayed out of the conversation was 41 things removed by hand with a pattern, a filter that should itself be a lens and be seen - exactly: you see it. Looked at first: every file every place keeps held no token, key, channel or address of someone, and one address of a machine that no one beyond it can reach.

Rejected: A list of what may be read or run (a wall; and a lens only takes a shape from what is); a pattern kept in a script and run by whoever remembers (what was done by hand for the conversation); refusing the whole row (the words around a token are the author's, and stay).

2026-11-14

A lens that says nothing of where one stands is looked through from a place - lens@place - and sees what is in view from there: a star what it holds, a constellation its stars, an observatory all it looks at. So a constellation and an observatory are places a lens is looked through from, and nothing more. And looking through a lens from a thing leaves a step on the driver's trail; a record of work says where it was made - the things stood on since the last one - supplied by the act, never typed.

The author, 2026-11-14: are a constellation, its stars and an observatory now presented like everything else, like lenses - names of those lenses? And: the work is not seen by what was planned (dead-weight records) but when it happens, through ocoeco - traversing the relations, looking, supplying glimpses are the concrete moments where it is happening. Looked at: a place was a thing one could stand on, not something a lens was looked through from; and what a record of work advances was typed by the driver in every job, over what the record already derives from what it touched.

Rejected: A lens for each place (a place is where one looks from, not another lens); holding a table as it stood to gain no field (the language grows: a field after those it had is growth, as a new relation is - what it had stays as it was, and the guard now holds exactly that); recording every look as a row (the trail is the driver's own; what it leaves in a place is where a record of work was made); keeping the typed advances as the measure of work (the act says where it happened).

2026-11-14

A change made through ocoeco is part of the record of work it says the same as: read off what both say, never typed; a saying several records share is the saying of none. Standing on a change shows where it is on GitHub; and on a page, an address of the web is a way out. So one walks from why something was decided, to the work, to what changed, and on to the code itself.

The author: to navigate anything from the abstract to the concrete and back. Walked on 2026-11-15, from an angle of the form to a decision to the record of the work - and there it ended: a change was in view as a thing and nothing joined it to the record that made it, nor led out to the code. Of 417 records of work, 349 said what a change in their place says; a record of work had nothing pointing at it.

Rejected: A field on a record of work for its change (a change cannot name itself before it is made; and it would be typed); a page of the site for every change (some two thousand: the code is on GitHub, and the way there is an address).

2026-11-15

The route through git history says when a change was made in UTC - 2026-11-14T23:08:46Z - as every record of work, run and turn says its moment, whatever clock its maker kept. What git answered before is asked anew.

On 2026-11-15 at 19:46 UTC the flow said the latest thing in view was at 20:46. A change made on the lab says its moment in the lab's clock, an hour ahead - 2026-11-15T00:08:46+01:00 - and read as words, as a lens orders and compares moments, it comes after everything said in UTC within that hour; the engine too, asked to read it as a moment, drops the offset and keeps the hour. A lens that takes a change for following a thing said would be an hour off. A moment said in one clock is told apart by what it says alone; one said in the clock of whoever made it has to be worked out each time it is read.

Rejected: Working the moment out in every lens that reads one (the same working-out written again in each, and forgotten in the next); keeping the maker's clock and reading moments as instants in the engine (which clock a maker kept says where a machine stood, not when the change was made - and git keeps it, where it stays).

2026-11-15

A part laid out once for each of something says, at its heading, the thing it is laid out for, where its value names one: the thing of that name, or the place of that star. While a site is laid out, the heading says that thing's page too, and the page leads there from the heading: a star's card, to the star.

The first observatory's whole stands its stars side by side as cards, as the engine's front page does; the engine's cards lead to each star, and the language's led nowhere. A line already says the thing it is about, and a surface leads to its page; a heading said nothing of what its part is for, though the part knows: it is laid out once for each value of a column, and that value is a star.

Rejected: A line of its own in each card to lead to the star (the card's name is the way, as on the engine's page); a heading that knows stars (it knows a value, and asks the names of things what that value is); a page lens that builds an address from a star's name (the page is the site's to say, by its own lens; the surface only leads where a plane says).

2026-11-15

The shape that tells an address of someone lets through a lens looked through from a place named as GitHub names its pages: around@marshall-oco.github.io is written as an address is, and is no one's.

Reading two more transcripts into the conversation's place on 2026-11-15, the place's own check stopped the turns from being kept: one held an address of someone. It was a lens looked through from the author's observatory. What a place keeps out is clarity and not a wall: a shape that takes what is not an address for one hides what should be seen.

Rejected: Changing the words of the turn (a turn is kept as it was said); letting the turns in past the check (the check is how nothing to be kept out gets in).

2026-11-15

A lens reads a table whichever lens in view declares it - one built into the program or one a place brings - and its shape is checked among the lenses in view from its place, not among the program's own alone. Where a lens reads a name that no lens in view declares as a table or names as a shape, the look says so, in words.

On 2026-11-15 a lens was made to say what followed a thing the author said - read off the records of work by their moments, in place of an overview drawn by hand in a chat. It reads turns, which the conversation's own lens declares, and the look stopped with the engine's words: Catalog Error: Table with name turns does not exist. What a lens reads was looked for among the tables of the lenses built into the program only: a table a place adds to the language could be read by the one lens that declares it. One lens defines a piece of data, many read it - that is how the language is meant, and it held for the program's own lenses alone.

Rejected: Making what followed parts of the conversation's own lens (it would then say where one stands, and a lens that does is no longer placed with every other); declaring turns a second time in the lens that reads it (a table has one lens); leaving the engine's own words to say it (they name a table, not what the lens lacks or where to look).

2026-11-15

A look may be in passing: looked through from a thing without standing there, and no step is left. To stand on a thing is a driver's attention being there; a comparison of how something looks, or the timing of a look, is not.

Since a step is a thing, a comparison of how standing on a thing looks before and after a change left a step by looking, and saw it the second time: the look moved what it looked at. With two things in one comparison every look would have left another. Seen on 2026-11-15 in the first job that used oco-work.

Rejected: Standing there first, so the step is in both looks (it holds for one thing, and a comparison of two moves between them); steps left out of what is compared (they are things like any other, and should compare).

2026-11-15

A name says what it means where one is about to use it: when what fits offers the fields of an entry, each says the first sentence of the word of its name. The words of the shared language go where the program goes - the program carries the words ocoeco's own place keeps, as they were when it was built - and a place's own word for a name is the one said there. The lens of language counts a lens as saying what it is by what it says of itself, and lists what still says nothing.

The angle with the least work toward it was holding it in one's head. On 2026-11-15, 143 words were entered for the names of fields and tables - 150 of 160 field names and 39 of 42 table names then said what they mean: most of it known nowhere but in the program and in a conversation that ends. A meaning kept in a table and shown nowhere is not felt; and from a place alone the words were out of view.

Rejected: A meaning written on each field of each table (one name means one thing wherever it is carried: said once, as a word); meanings only where ocoeco's place is in view (a name should say what it means in any place the program is used); counting a lens as saying nothing where no word bears its name (every lens says what it shows: that is its meaning).

2026-11-15

A thing's whole name is where it is held - owner and place - its table and its id. Its shorter name, without the owner, is its name only where no other thing goes by it: a name of several things is the name of none, and a line about it leads nowhere. A site leads to a page by every name that names its thing alone; and no two of its pages are written in one place.

Sign a-shorter-name-is-several-things. And the site command had been landed before it was tried - the trial failed for a reason of its own making, and the job went on: tried afterwards, it showed this. The trial is now part of the job, and each part of it a reason to stop.

Rejected: The shorter name going to whichever came first (a way that leads to the wrong page is worse than none); whole names everywhere (the shorter one is what is said and read, and is one thing nearly always).

2026-11-15

A part of a lens is known by one name: the id it is kept as. A lens kept as rows names each part by the id its row is kept as, and the graph finds it by that id alone; a lens kept as a file has no ids of its own, and its parts are named by where they stand in the file - which is then the id. Records of work that touched a part since taken back now touch what is still kept: the lens it was part of.

On 2026-11-15 two looks at one whole gave two answers: through what was observed, two records of work pointed nowhere; over the places held, the same records were said to hold. Read off the source: turning the lenses in view into rows named every part by where it stands - the fifth, the sixth - beside the rows a place keeps under their own ids. So over places held a part had two names, and a link to a part taken back landed on whichever part stood in its place. What was observed names parts only by their ids, and saw it. The two records date from before taking a row back looked at what points at it.

Rejected: Renumbering what a place keeps so that its ids follow where its parts stand (an id is what is pointed at: it does not move when another part is added or taken back); a link that says what it pointed at was taken back (the two are what came before taking back was refused when pointed at; a part to carry for two rows); leaving the two records as they were (history, but a link the whole says points nowhere is a sign every look then carries).

2026-11-15

Work done by hand is counted by naming its record: ocoeco manual --id ID counts it as it is, without its words said again; a record that is not kept is not made of nothing. Where neither words nor a record are given and there is no terminal to choose in, that is said in a sentence.

On 2026-11-15 a job counting the day's handwork named each record by its id, as the command says a record is bumped, and stopped twice with a panic - failed to initialize terminal: without the words of the action the list to choose from was opened, and a job has no window. What it lacked could have been said in a sentence.

Rejected: Asking for the words each time (the record already has them: a thing typed twice drifts); opening the list wherever nothing was said (where there is no terminal that is a panic, and says nothing of why).

2026-11-15

What a route reads of a place both held and observed is read once: a row of one place under one id is one row, the first to arrive - looking from a place, that is the place as it stands.

Since where one stands is read as it stands, a place looking at what it observed is in view twice: held, and observed. Rows a place keeps were already one row by two routes; rows a route reads - a change, a document, a guard - were not, and the lens of results listed each change of the place one stands in twice, on the published pages too. Seen on 2026-11-15 by looking at the whole one step up and then into results: found by looking, the day it came in.

Rejected: Passing over everything observed of a place held (what only observing brings - what has run, what was released - is kept by no place, and would go out of view).

2026-11-15

A row is taken back by saying so: ocoeco take-back, the table and the id. It is no longer kept where it was - refused, and put back, where something in that place still points at it. The inverse of entering one, and guarded the same way.

Sign a-row-cannot-be-taken-back: each merge of two things of one nature - the act the whole is refined by - ended in changing a place's files by hand, with a program outside the language. Moving rows between places with every link rewritten was already an act; taking one back was not.

Rejected: A mark on the row saying it is no longer so (what is taken back would stay in every look, to be filtered by each lens); renaming a field through it (a field is the shape of a table and is named in what parts ask: that is still made by hand, and is said so).

2026-11-15

The pages of a site are read from everything its lens brings into focus - also from what a lens placed in it brings. So a place may offer pages of what it holds, as a lens of its own, and an observatory place them among its own. The lens of the site is asked once.

The conversation's place holds the turns and the lens of what followed them: a page for each thing the author said is its to offer. The author's observatory could not ask for them itself - a lens is checked from its own place, where the conversation's tables and shapes are not in view. A lens of lenses says only what to place together: that held for what a page shows, and not yet for which pages there are.

Rejected: The observatory's lens reading the conversation's shapes (it cannot be checked from its own place: what a lens reads must be in view where it is kept); telling the author's turns from the agent's by which turns a record of work entered (true today by how turns are entered, and wrong the day an agent's turn is entered the same way).

2026-11-15

A site is said by a lens: each row of what it brings into focus is a page - where it is written, what it looks through, and the thing it is the page of. ocoeco site lays each out on a surface. While a site is laid out a plane says, for a line about a thing that has a page, where that page is - and the page lens makes that line's words the way there. So a walk on the web is pages that lead to one another: nothing fetched, nothing run, and which pages there are is rows a place may say for itself.

The author: what is most important is navigating - and the perfect form does not say on what surface. The published page was one page, and could not be walked. The engine's site is many pages written by a program; looked at on 2026-11-14, what the fulldome lacked of it was a page for each place. With a surface said by a lens and a plane saying what each line is about, which pages there are was the one thing left unsaid. Tried on what the author's observatory last observed: the whole, with the ways to other pages taken out, is the page the program writes, byte for byte.

Rejected: A script in the page that fetches and draws (a second program, on a surface that cannot be looked through); a loop in the workflow (which pages there are, said where no lens sees it); a page for every thing at once (some nine thousand: a site says which it has, and may say more).

2026-11-15

A step is kept as a row: who stood where, and when. Where ocoeco keeps its trail on a machine is a place that machine holds - it says so itself, once - and steps are a table of it: in view from an observatory standing there, never gathered, never leaving the machine. A step is a move; standing again where one stands is not one; and steps do not pile up without end. A step is about the thing stood on, so standing on a thing shows who stood there and when; and the lens of the flow says where each driver stands now, read off their latest step.

The author: me using the window is itself a flow of data; what I am working on becomes intelligible and exactly derivable from what I do in it. Sign where-the-drivers-stand-says-nothing-of-when. oco-agent already kept its own record as a place of the machine; the trail was beside it and said nothing of being one.

Rejected: A new way in for the trail (it is rows in a file, of a place: the way in there already is); every look as a step (looking again where one stands is not moving); steps gathered with everything else (where one looks is one's own, and of that machine).

2026-11-15

Looking through a lens from a thing, the lens may read that thing in full: in_full, a table the program gives for the thing stood on - a row for each field it carries, as it is kept, by whatever route its rows come. The lens of around says it first: itself, in full, in the order its table declares its fields. A lens that reads it is looked through from a thing, as one that says {here} is.

On 2026-11-15 what followed a thing the author said became a look: each line of it is about a thing, and a step down from a line led to a page that said the thing in seventy characters - the few words the graph keeps of everything - with all that is around it, and nothing more of what it says. The why of a decision, what it rejected, what a reflection learned were read only in the files of the place that keeps them: outside the ecosystem. A thing is what it says before it is what it points at.

Rejected: Keeping every thing's whole row in the graph (the graph is made of everything in view for every look: the words of three thousand turns would be carried to each); laying a table out as itself from a thing (the passthrough says a row as one line, field after field - a decision's why and what it rejected run together); a lens for each kind of thing (what a thing carries is said by its table: one part says any of them).

2026-11-15

A thing says when: by the field its table says dates it, or else its moment, or else its day - where that is shaped like one; a moment kept as seconds is said as a moment, so all of them sort as one. The lens of the flow is everything in view that says when, the latest first, whatever kind it is and wherever it is held. Standing on a thing shows what came just before and after it in its place: a step in time, as the rest are steps along what points at what. And a look may follow: it does not end, is asked again when what is in view has changed, shows the whole anew on a screen and elsewhere only what newly came into view, and waits without load.

The author: it is a process of a whole, with no defined start and no end; idle, it flows without load like an open window; in progress is not a one-time render but a continuous reflection of observed signals. Looked at on 2026-11-15, the angle nothing had touched: nothing in the graph said when - the whole was a still picture, drawn again each time. Sign the-whole-has-no-time-in-it. A process cannot begin with a program that stays running if what it shows has no time in it.

Rejected: A program that stays running and holds the whole (the next thing, perhaps - and it would have had nothing of time to hold); a table of events kept beside the things (when is already said, by each thing, in the field its table names); the look that does not end as the window's own (it belongs to no surface: any look may follow).

2026-11-15

What a place adds to a lens it does not keep - a relation, a part, an entry, a route said for a lens the program brings or another place keeps - is joined to that lens wherever it is in view: the lens looked through is the one it names, and this besides. Only what is added is recorded; the rest is referenced. A table stays defined by one lens: nothing is added to another's. The check says when a place adds to a lens that is not in view from it.

The author: no concept of a wrong lens - adjusting makes a new lens that changes the composition of the previous one a little, like a new node where only what is added or changed is recorded and the rest referenced. Sign what-is-added-to-a-lens-is-dropped: the first relation the ecosystem tried to add to itself by its own means was dropped without a word. Measured 2026-11-15: with it followed, the 538 guards each point at the file they are in.

Rejected: Copying the lens into the place to change it (the whole recorded for a little added, and two lenses of one name); adding the relation to the lens in the program (right for this one, and it leaves the next adjustment a change to the program again); adding fields to a table another lens defines (one lens defines a piece of data: widening it is another question, not answered here).

2026-11-15

In the window an entry is made by saying its name where one stands. Said alone, it is shown what it asks, which of its fields point at things, and where it would be kept. Said with what it asks beneath it - each as FIELD: words - it is made by the entry itself, as it is made anywhere, where the thing stood on is held or in the place given. In a field that points at things, here names where one stands; where no name is given it is named by its first words. One then stands on what was entered.

The author, 2026-11-15: one acts from within. The window showed which entries can say something of the thing stood on, and they had still to be made from outside - a command, its flags, the thing's name typed again. Standing on the thing already says what the entry is about. And his word the same hour: the program is what expresses the inside from outside for now, as assembly once did for a language; what it does is to be said from inside as the inside grows able to say it.

Rejected: A form made in the program and asked field by field (a driver without a terminal answers in one turn; and what an entry asks is the language's to show - a lens of it is what comes next); the link to where one stands supplied without being said (an entry may point at things by several fields, as a connection does by from and by to: which is meant is said, as here).

2026-11-15

An entry said in the window is made standing in the place it is kept in - an entry a place's own lens declares is known there, and nowhere else - and where it is not made, all of why is said. In a field that points at things, a mark names what it marks in what was last shown, as here names where one stands: a thing is pointed at, never named from memory.

The first entry said in the window, on 2026-11-15, was the author's own turn - standing on the turn before it - and it was not made: the conversation's entry is declared by the conversation's lens, the window asked for it from the observatory's folder, where it is not known, and of the reason only its last line came back: For more information, try --help. And a connection says how one thing bears on another: standing on the one, the other was still to be named by typing what it is called.

Rejected: Every entry of every place known from wherever one looks (an entry belongs to the lens of a place, and two places may call different things by one name); the other thing named by its id (remembered from outside, or copied by hand from what was just shown).

2026-11-15

The lens of the graph says what is joined to nothing - it points at nothing and nothing points at it - by kind, beside what nothing points at. An island is a gap in the whole: something taken in and not yet joined to anything. The sheet of the perfect form shows the islands.

Looked at one step up on 2026-11-15: half of everything in view - 5094 of 9969 things - was said to have nothing pointing at it, every change and every guard among them. But a change is part of its record of work and a guard is part of a file of source: they point, and are joined. What nothing points at mixes the leaves of the whole with what stands apart from it; and what stands apart - a translation, a release, what was done on GitHub - is what is not yet seen in the whole.

Rejected: Changing what the older part counts (what nothing points at is true as it is said, and a place may place it); a number alone (which kinds are islands is what shows where the whole has a gap).

2026-11-15

What git answers for a commit is asked once, and kept beside the repository under that commit: a place's history, and a table kept on another branch. It is found again for as long as the name stands at that commit, and asked anew when it has moved - read from what git keeps of where its names stand, without asking git. Where that cannot be read, git is asked each time, as before. And the graph says where its own making went, stretch by stretch, in a lens's beam.

Sign making-the-graph-takes-time-not-understood. Timed stretch by stretch on 2026-11-15, the graph's 400 ms were not where they were looked for - working out the lenses in view took 7 - but in reading: 137 ms for what the places keep and 90 for what the routes read. 57 tables are kept on another branch and 27 places have a history: some 84 questions to git on every look, two or three thousandths of a second each. A commit does not change, so what was answered for one is exact for as long as the name stands there.

Rejected: Keeping answers for a while (it would show what was as if it were so now - what is kept here is kept under the commit, and is exact); asking git side by side (less to wait for, and still asked every look); a program that stays running to remember (the same, held in a program instead of beside what it is of).

2026-11-15

Each time something is done by hand is a row of its own: counted again within the same second, it is named apart - by its moment, its record, and which time of that second it is.

On 2026-11-15 a job counted three waits for a run, and later three looks at a page, one after the other: each time was written as a row named by its moment - to the second - and its record, and those of one second were named alike. The first observatory kept 16 times done by hand under 3 names. What is counted by its rows was counted rightly, and none of those rows could be told from its twin, pointed at, or changed.

Rejected: A moment to the thousandth of a second (two times can still fall on one, and every other moment in the records is said to the second); one row saying how many times (each time has its own minutes and load, and what was done by hand is counted by its rows).

2026-11-15

A lens of lenses that stands on a thing places lenses that look from a thing, from there. Placed by its name, a lens that looks from a thing stands where the placing lens stands; placed as every lens, they are the lenses that look from a thing, each left out where it brings nothing from there. From nowhere every lens is, as before, every lens that looks across - and a lens that looks from a thing places none. The lens of around places them: standing on a turn of the author's, one is shown what followed it.

What one sees standing on a thing was said twice for a turn of the author's: a page looked through what-followed, a step in the terminal or in text looked around. A step is one on every surface - around the thing - and what else looks from a thing belongs to what is around it: said by a lens of lenses, not by which surface one happens to be on.

Rejected: A lens declaring which kinds of thing it stands on (it says so already, by bringing something or nothing from there); a page of its own for what followed a turn (a second answer to standing on the same thing, on one surface only).

2026-11-15

Standing on a thing shows what changed for it: the changes that are part of the work that was about it, each with where it is on GitHub - two steps of the walk, taken as one. And a look cut short by whoever reads it ends there quietly.

On the site a decision has a page and a record of work has none: from why something was decided the way to what changed was two steps, and the second led off the site. The lens of around can take both at once. And a look piped to something that stops reading ended with words of a failure that was none - seen in a dozen outputs and passed over.

Rejected: A page for every record of work (four hundred more pages for a step that can be taken at once); leaving the words of a failure (a person looking at the first lines of a look is told something broke).

2026-11-15

A row is taken back only when nothing in view points at it: from a place, nothing in that place; from an observatory, nothing in any place it has in view. What is said to hold everywhere is asked of the whole - no link in view points nowhere - and not of one place against the others.

On 2026-11-15 a part of the author's sheet was taken back from his observatory, where every place is in view, and a record of work in another place was left pointing at nothing. The refusal looked at this place's own links; and the word in oco-work for 'every place holds' ran a check that looks at one place. The graph over the whole saw it, and the voice said so.

Rejected: Looking only where one stands (from an observatory the whole is in view: that is what it is for); checking each place in turn after every landing (twenty-seven checks of three seconds: the whole says it in half a second).

2026-11-15

A lens looked through from somewhere - from a thing, from a place - has its beam traced as it is looked through from there: the beam of that look.

Asked for on 2026-11-15, the beam of standing on a thing said nothing: the beam took the whole of around@thing for a lens's name, and found none. A step of the walk was the look whose cost was least understood, and the one look that could not say where its time went.

Rejected: Leaving the beam to lenses looked through from nowhere (the walk is looked through from a thing every time).

2026-11-15

The page is drawn by what the plane says, and the plane says two things more. A lens placed as one of every lens in view says so (of_every): the page lays open what a place put first, by name, and folds every other into a card that shows its name, what it says of itself and its figures - an index of the whole. A part laid out once for each of something says what (per): parts of one kind, where each is short, stand side by side as small cards - a star with its idea and how far it has come. Within a part the page draws by what the lines carry: measures as rings, a chain stepped in, short lines in columns, sentences as rows - the first eight of many, the rest folded beneath. What a line is known by is set strong where its words say that name; a thing named whole is the way to its page. The page of a place's whole is headed by what the place is called - the name on its mark - and says under it what the whole says it shows.

Looked at on 2026-11-15, the page said by a lens was every part as a box the width of the page, one under another: 85 parts of the first observatory's whole in one column, and nothing said which came first. The engine's front page was still the one a visitor meets, because it shows each star as a card with its milestones as rings. Looked at before replacing: those cards are a composition the language already has - a part laid out once for each star, a measure on a line - which the engine draws by knowing what a star is. A surface can draw it by a meaning, knowing nothing of stars. What was lacking was two things the program knew and did not say: whether a lens was placed by name or as one of every other, and that a part is one of several of one kind. Said in the plane, any surface may use them; the page does. Tried four times on the lab without landing, and looked at each time in light, in the dark and at a phone's width before the next.

Rejected: A card for every part, side by side (tried first: 80 of 85 parts are lists of sentences, and a narrow card breaks a sentence into a column of fragments); a field by which a lens says how it wants to look (a lens says what a thing means and a surface how it looks, so one lens looks right on every surface); telling a star's name from the punctuation of a line (the plane says what a line is known by, and nothing is guessed from words); the name The fulldome at the head of every whole (a visitor meets a place, and a place has a name); folding by a number a place sets (the page folds by what is there: what came as one of every other, and what is long).

2026-11-15

The page is said by a lens: as-page lays a plane out as a page of the web - each part a section, its heading and its lines as a list, a measure as a meter - with its frame and its style in what the lens says. A plane's rows say where each comes in its part and how many lines the part has, so a surface knows where a part begins and ends from the row itself. A frame may say {scale}, which whoever asks for the page fills with what is looked at and when.

Looked at through the lens of the program on 2026-11-15: of 105 changes to ocoeco in four days, 82 changed only the program - 12,476 lines added, against 1,835 in what lenses say. The program is changed from outside because it keeps being where things are said. The page was 57 lines of it, and how the page looks was a line of program too. Measured: what the author's observatory last observed, laid out by the program and by the lens - the same, byte for byte.

Rejected: Changing how the page looks while saying it in the language (it cannot be looked at from here: equal to what was is how it is known to be right); taking the program's page away at once (it is what the lens is held equal to, and one observatory still asks for it); letting go of the commands nothing outside asks for (looked at: the search by topic is the commons' open door, and recording work done by hand is a designed thing with its own reasons).

2026-11-15

The parts of a lens ask the engine in one go: what the lens gathered is loaded once, and each part's question is answered after it - a part finds its answer by its place among them. Where they cannot all be answered together - one of them fails, or the engine answers some other way - each part asks for itself as before, and says for itself what is wrong.

A step of the walk took 1.2 s and the author's sheet 2.6 with the graph made in a third of a second: most of a look was not the graph. Read on 2026-11-15: each part of a lens asked the engine in a run of its own, and every run loaded everything the lens had gathered again before answering - the whole graph, nine times, to stand on one thing. Found after the graph had said where its own time went, and it was not there.

Rejected: Keeping the engine running between looks (a program to hold, where asking once is enough); fewer parts in a lens (a lens says what it shows: how it is asked is the program's).

2026-11-15

The program no longer has the page or markdown as surfaces of its own: the page is the lens as-page, and its old name, html, asks that lens. The guard that held the lens's page equal to the program's goes with it - there is one page, and nothing to hold it equal to. And gathering each table is timed: a lens's beam says, beside by which route a table came and as of when, how long it took, where that is worth saying.

Sign the-page-was-said-twice. Both observatories ask the lens for their page as of 2026-11-15, and no workflow asked the program for one. Looked at through its own lens, the program had grown by twelve thousand lines in four days; this is the first time it holds less. And a step of the walk had come to take a second and a half, slower than any other ordinary look, with nothing saying why: the author asks that what is not as wanted be seen in its projection, not guessed.

Rejected: Keeping the program's page as a second way (two of one nature, and a guard to carry); taking the text surface out too (a look is asked for many times a minute, and saying text through a lens costs it another question to the engine); guessing where the time goes (twice in these days a guess about cost was off).

2026-11-15

A walk belongs to no surface. A plane says, for each line, the thing it is about - what its answer names as a thing, or its star and id where they are one thing only: never what its words suggest. Where a driver stands is kept beside the trail, and stays when the trail begins again: a lens that says where one stands, asked for from nowhere, is looked through from there - on whatever surface the last step was taken. To stand is one act, the same everywhere. A surface lays out what can be stood on its own way - a completion, a link, a pointer, a line to read - and adds nothing of its own. The terminal window is given the plane's rows like any other, and finds nothing by itself.

The author, 2026-11-15: the perfect form does not say on what surface the interaction is, and the terminal window has a lot of excuses that make friction with it. Looked at: every part of the lens of around already named, as a value, the thing each line is about; looking and entering were already the same two acts everywhere; where one stands was already data. The window had its own copy of each. Sign the-walk-lives-in-a-window.

Rejected: Making the window better at guessing (more of what was in the way); a walk of its own for each surface (the same excuses, once for each); taking the window away (it is one surface among others, and the open one - only not the place where walking lives).

2026-11-15

The way up from a look is a surface said by a lens: as-outline lays a plane out one step up - each lens placed in it by its name and what it says of itself, its figures, and each part by its heading alone; parts laid out once for each of something as one line, how many and which. The whole in view is then some hundred lines, and the way back down is what a line names, looked through by itself. It is the page's folded cards, said for text: one meaning - a part is its heading and how much it holds - on two surfaces.

Asked on 2026-11-15 whether the work still dives up through the ecosystem itself, the driver looked: the whole in text was every line of every lens, thousands of them, so each job cut a look down by hand - its first lines, the lines that begin a part - many times that day. A cut by count hides whatever comes after it, and nobody can say what it hid. The canon already says the form - every layer is the top of the layers beneath it; an outline is generated from the thing itself; a cold read is given the outline alone - and the page had been given it the same day, a lens folded to its name, what it says and its figures. Text had not. Tried first as a lens brought by a throwaway place, with no change to the program: the whole came out as 117 lines, and in them stood what no look of the day had shown - a run failing on main, there for ten minutes between two observings, and a change listed twice.

Rejected: A flag that cuts a look to so many lines (a cut by count hides whatever comes after it; an outline hides nothing of the shape); a command of its own for the outline (a surface is a lens: it lays out any plane - the whole, one lens, a sheet - and a place may say its own); cutting short what a lens says of itself (it is the one line that says what the rest is).

2026-11-15

The whole one looks through is the one the place one looks from says for itself - a lens of its own that places every lens - in the window, as text and as a page alike; where it says none, every lens in view as they come. It is read from that place's own lenses, not found among all in view.

The rule was first written as the whole a place in view says: an observatory that has another in view would then begin on the other's sheet - the first observatory on the author's. And only the window followed it; the whole as text and as a page still came as the program orders it.

Rejected: Finding it among every lens in view by who keeps it (what was observed does not say who keeps a lens; the place itself does); a name for it in a place's mark (a lens that places every lens is already what a whole is).

2026-11-15

The window in the terminal opens on the whole a place in view says for itself - a lens of its own that places every lens, with what comes first - as the page does; where no place says one, on the flow of work, as before.

Looked at on 2026-11-15 for the first time, through a recorded terminal replayed into the screen a person sees: the window opened on the lens of work, whose first screen was where a driver had stood, while the author's observatory says what it shows first - its sheet, then the perfect form - and its page honours that. Walking in the window, guarded by tests and never taken, was taken: right began it, down moved, Enter stood on a sign, the line of keys said what they now do, and the step was kept.

Rejected: A lens named in the program as where one begins (what a place shows first is the place's to say, and it has said it); a new field for it (a lens that places every lens is a whole: that is already what it is).

2026-11-15

Said with no command - nothing at all, or words that name none - ocoeco is the window, where there is no terminal to move in: one is shown where one stands, a mark before every line about a thing, and says a mark to stand on what it marks, a lens by its name to look through it from there, back, or up. What is shown is what lenses bring into focus - around the thing stood on, or what the place shows first - laid out by a surface a lens says, as-window: the lens looked through whole, what it places one step up. What was marked is kept beside the trail, and a plane gives each thing its mark. Standing on a thing, the lens of around also says which entries of the language can say something of it.

The author, 2026-11-15: the interface is to be actually interactive - one stands in it and acts from it, it presents itself from itself, and one navigates from within, not by remembering where something is or which flag a command takes; not even what fits as one types; and it is all just another lens of lenses. A page, he said the same hour, is only one surface a lens of many lenses projects to. The agent had kept walking outside: looking through commands with flags held in its own context, reading the places' files and pages from its workspace, composing each act by hand. The fulldome in the terminal is a window for whoever has a terminal to move in, and it is made in the program, behind its brackets; a driver without a terminal had none.

Rejected: More flags, and what fits as one types (a line to be typed is still remembered from outside); a window made in the program for drivers without a terminal, as the terminal's is (what a window shows and offers is a lens of lenses, said in the language: any surface lays it out); a mark numbered by each surface for itself (the mark one says must name what was shown: the plane gives it, once).

2026-11-15

What a place has is kept by table and id, made once all its rows are read: whether a link holds is found, not looked for through every row of the table each time.

A step of the walk had come to take a second and a half. The beam, timing what it gathers since 2026-11-15, said the graph took 571 ms of a one-second look; each thing it is made of, looked through as itself, took a few hundredths. Read: for each of some seven thousand links the program went through every row of the table pointed at - and each of 2,900 turns points at the one before it. Found by a look saying where its time goes, after two guesses about cost in these days had been off.

Rejected: Keeping the graph from one look to the next (it was not the making that was slow, but one question asked the slow way); a program that stays running to hold it (the same).

2026-11-15

A lens may read what was just given in the window - given: each field named, and its words - and what was marked in what was last shown - marked: each mark, and the thing it marks; and it may say who is looking: {who}, the driver. Going up is kept as a step - who left what, and when - so that where one stands is read off the steps: the thing of one's last step, unless it says one went up from it. Where a lens called entering is in view, an entry said in the window - by its name, or by its mark where it is marked - is said as that lens says it: with nothing given, the lens is looked through from the entry and shows what it asks; with what it asks given, the lens says the row it would keep - each field and value, and the place it is kept in - or what is lacking, and the program enters what the lens says. One does not stand on an entry: here stays where one stands. Where no such lens is in view the program says it itself, as before.

The author, 2026-11-15: the program says the inside from outside only until the inside can say it itself - a hand that draws itself. What an entry asks, how the row it makes is named, which thing a word like here or a mark points at, and where the row is kept were all said in the program. A lens can say them once it is given what it lacks: the words just given, what was marked, and who is looking - where one stands is then read off the steps, which is why going up had to become a step: the trail said one still stood where one had left. The lens is made and tried as a place's own first, and built into the language once it says what the program said.

Rejected: Where one stands handed to the lens by the program (it is in the steps, once going up is a step too: the lens reads it); an entry stood on like any other thing (here would then name the entry, where one came from would have to be guessed from the steps before it, and every record of work would say it was made standing on an entry); the lens built into the language before it has been tried (a lens that does not come into focus stops the check of every place); the program's own saying taken away at once (until the lens says all of it, the way in must not close).

2026-11-15

In the lens of work, what is in progress and what was finished lately come first; where the work is happening - the things a driver stood on - comes after.

Looked at on 2026-11-15, in the window and as text: the lens of work opened with twenty lines of where a driver had stood, before what is in progress. From a place that says no whole of its own, that is the first screen a person meets. Where one stood is how what is in progress is read off - the ground under it, not the first thing to read.

Rejected: Leaving the order as the parts were written (it was the order they were made in, not an order chosen for a reader).

2026-11-15

A lens may say what comes first: a part that places every lens places every other - not one a part before it has placed, and not a lens that looks from a thing, which from nowhere has only how to stand to say. A page is headed by what it is - the title its row gives it - and has a way back to the whole. And an entry may supply the moment, to the second, where a day is not enough.

Looked at on 2026-11-15, as a browser draws it, for the first time since the page was said by a lens: the first thing on the author's published page was the lens of around telling a reader to type a command, then nine turns that said continue; his own sheet was near the bottom of 1,900 lines; every page was headed The fulldome and none led back. The page had been held equal, byte for byte, to what the program wrote - and that was a poor front page. The observatory's practice says to look after a change to how something looks; I had said I could not, with the tool for it on the lab.

Rejected: An order of lenses fixed in the program (what an observatory shows first is the observatory's to say); holding the page equal to what was (it told that nothing had changed, not that it was good).

2026-11-15

What the lens of language shows of the language is answered in the language. A line written twice is said once, as a named shape: how a pointing is said, in the lens of around. A table that leads to no surface is brought to one or let go: each time something was done by hand is brought into focus by the lens of results - what it took, the most first - and each such time repeats the work done by hand it is a time of.

Looked at on 2026-11-15, the lens that looks at lenses showed three things of the kind the author asks to be looked for: a name holding two kinds, a line written twice, a table nothing brought into focus. The table is the handwork itself, recorded by five places and seen by none - and what the engine's site shows as manual work worth a tool, which the fulldome lacked.

Rejected: Letting the table go (it is kept, and it is what the author means by handwork: what would be most worth making through the system itself); leaving the line twice (small - and the lens exists to show it).

2026-11-15

Looking from a place at what was observed, the place one stands in is read as it stands and every other place as it was observed: the place, where it has a mark, is in view beside the folder of what was observed, and what that folder holds of the place's own lenses is passed over. Its lenses are then looked through as they are now - the same lens that names the whole - and a change to them is seen at once, not after the next observing.

On 2026-11-15 the whole was named from the place's own lens and brought into focus through the copy in what was observed: a lens just changed was looked through as it was. Twice that day it stood in the way - the first observatory's face, tried before it landed, had its rows copied by hand into what was observed; a check that the author's whole had its new name read the old one and stopped a job whose change was right. Both places held and observed already meet for rows, which are one row, the first or the freshest; for a lens, two of one name stopped the look.

Rejected: Observing again before every look (minutes, and a trial before landing would have to be published to be seen); reading every place as held when one stands in an observatory (what was observed is the whole as one moment, and what the published pages are made of); passing over what was observed of every place held, rows as well as lenses (a row already is one row by two routes, the freshest, and a guard holds that).

2026-11-15

A change to the language is checked where it is read: the language's own place, checked with the places beside it, brings into focus every lens they keep, each over its own place, with the language as it is there. And a lens that looks from a kind of thing comes into focus, in any check, from the last thing of that kind its place keeps - so what it asks is asked with rows passing through.

The shape of the signs nothing has come of was said anew from the window, and the landing was checked in the language's place, where only its own lenses come into focus. The conversation's lens of what followed asks of that shape, and failed in the engine when looked through from a turn; brought into focus from nowhere, nothing passes through it, and nothing would have failed.

Rejected: Every place checked again after each change to the language (minutes, where the lenses that read the language are a few); a list of the lenses that read each shape, kept to know which to check (kept by hand, where bringing each into focus says it).

2026-11-16

A driver's first step keeps the trail as a place of its own, and what is in view is read again after each thing a saying enters: so here and back name what was just made in that same saying, from a driver's first step on.

A trial driver with no steps yet said a sign and the connection leading from it at once: the connection's here named nothing, for the trail became a place only with that first step, after what was in view had been read.

Rejected: A trail kept as a place before anyone steps in it (a place with nothing in it, made on every machine that runs the program).

2026-11-16

A part that places a lens may say the lens it is seen through - through: a lens that reads a plane. What the placed lens brings into focus is then given to that lens as its plane, and what it lays out - or leaves out - is what the part shows: a lens behind a lens, kept in the lens that places them. So a lens that differs from another is made by adding, never by changing: it places the other, adds parts of its own, and sees the other through a lens that leaves out what is not wanted. The part points at both - it places the one, and is seen through the other - so the arrangement is in the graph like everything else, and can be walked.

The author, 2026-11-16: if I want something different from a lens A, I add a lens B that includes A; to add, more lenses on its plane; to filter out something of what A projects, another lens behind it - all of it in B, reflected in the lens structure, nothing hidden. All of that held but the lens behind: a surface could be put behind a lens only at the moment of looking - as-window@lens - and no lens could keep it. Looking through a lens from a lens already worked, lens behind lens, to any depth; what lacked was a part's way of saying it.

Rejected: The filtering said in the placing part's own query (a part that places asks nothing; the lens behind is a lens, reused wherever it is wanted); the two written into one name, behind@placed (the name would point at no lens, and the graph would not show the second); only widened to leave lines out (only picks one heading of what is placed: leaving out is another lens's saying, not a flag on this one).

2026-11-16

A lens that looks from a kind of thing comes into focus, in a check, from the few things of that kind that came last - by when each says it was - and not from the last alone: the last may have nothing passing through it yet. And where the language changes, each lens a place beside it keeps comes into focus with all of those places in view, as it is looked through where the whole is seen.

The check with the places beside the language's place brought the conversation's lens of what followed into focus from its last turn, over the conversation alone - and the shape that had stopped it passed: what followed a turn is done in other places, and no row went through it.

Rejected: Every thing of the kind (hundreds of looks, where a few that came last carry what is asked now); the thing with the most behind it (asked of each lens in its own terms).

2026-11-16

A lens is of its place, as a thing is: two places may each keep a lens of one name. It is called from where one stands - the one kept there answers to the name alone, every other is called in full, place/name; where none is kept there, the name alone is no lens and the words say each in full. What a lens says of another by name means the one its own place keeps. In the graph a lens was always a thing of its place; only looking through it knew it by name alone.

Two places keeping a lens called site stopped every look that saw both, and neither saw why: the first observatory's lens of its pages had to be called commons-site because the author's observatory keeps one.

Rejected: Every lens always called in full (the language's own lenses and every lens that is one of its name would be said the long way for a meeting that is rare); the first place in view winning the name (whose lens a name means would turn on the order places are listed in); names kept one across the whole, with a prefix by habit (the habit is the sign).

2026-11-16

In the graph, what a lens's rows name - the lens a part is of, the lens it places, the one it is seen through - means the lens of that name its own place keeps; else the one lens of that name in view. Where several places keep one and its own keeps none, the name alone is no one lens, and nothing is drawn.

The first observatory's part of its lens site was drawn as part of the author's lens called site: looking through a lens had become of its place, the graph still read a lens's name across the whole. Standing on the part, it pointed at the wrong lens - and, renamed by hand with its lens, it had seemed to be no thing one could stand on.

Rejected: A relation of the language declared for each field a lens's rows name (the rows of the language are drawn from the lenses as they are, built-in ones too: no place keeps them as a table, so no declared relation reaches them); a part linked to every lens of its lens's name (a part is of one lens).

2026-11-16

A lens that looks from a thing may say the kinds of thing it looks from - looks_from: their tables. From a thing of another kind it is not asked: around such a thing it is not placed, and said by its name in the window it is looked through from nowhere, as it is where one stands on nothing. The lens of entering looks from an entry; what followed, from a turn.

Every lens that looks from a thing was brought around every thing, to say nothing: a third of a second in each look, for the lens of entering alone. And what followed, said while standing on anything but a turn, showed nothing - where from nowhere it shows what followed the latest thing the author said.

Rejected: Leaving each lens to bring nothing where it does not fit (it is asked every time, and the window cannot tell nothing to show from not from here); telling the kind from what a lens asks (a lens says what it is; it is not guessed).

2026-11-16

A part of a lens is said to rest on a shape, or to ask of a table, where the name stands in its query as a word outside what is quoted. Within quotes a name is words the part says or compares with, not something it asks of.

The link was read off the name wherever it stood as a word, so the part that names a row - which compares what was given with the word here - was drawn as resting on the shape here of another lens. A link the graph draws is followed: one that is not so leads astray, where one that is missing only fails to lead.

Rejected: Reading the query as the engine reads it, to learn what it asks of (the graph is drawn where no engine is, and a query that still holds here or today in braces is not yet one); a list of names never to be taken as shapes (it would be kept by hand, and wrong again with the next lens).

2026-11-16

A part of a lens goes by the name it was made with - one given to it, or, where none was, the place it was made at - wherever it comes to stand: its place among the others is not its name, as it was not for a part kept as a row. An entry may put a part where it is to stand (part: N); every part whose place then changes is written with the name it went by, and a part put among the others is given a name of its own, for a number names a place. And what is written above a part in its file is what the part says: read with it wherever the language is read, and written by its entry.

In a lens file a part was known by where it stands, so a part put before it would have taken its name, and whatever pointed at it - records of work, steps, connections - would have pointed at another. A part kept as a row already had its name and its place apart: still-showing/2 stands third. And the words above a part, where the files say what each part is for, were read by whoever opened the file, and by no lens, no entry and no window.

Rejected: Naming every part anew, by its shape or its heading (what points at a part by its number would point nowhere, and a heading changes); keeping a part's old name beside a new one (one part known by two names at once); a key says written in a part (the files already say it above each part: it would be said two ways in one file); a part taken away (a part that landed is touched by the record of its landing, and what landed cannot be taken back - a sign of its own).

2026-11-16

A place that keeps no lenses yet is given its first by an entry as a file of its own, in lenses/ - where the lenses of a place are read - as a place that keeps lenses as files is given another.

The phone's docs keep their test runs, and no lens says what a test run is; the place keeps no lenses, so a lens entered for it from the window had nowhere to be written.

Rejected: The place given rows of lenses to keep in its mark first (a mark said for one lens, where a file is read as it is); the lens kept for it in another place (a place says what its own tables are).

2026-11-16

A link may be said of what was: a record of work points at what it touched and where it was made, a step at what was stood on, each as it was when it was written. A thing taken back since is what the record said then: the link does not point nowhere, and it keeps nothing from being taken back. So a row that landed may be taken back where only what was said of the past points at it - and two things found to be of one nature can become one.

Every row that landed was touched by the record of its own landing, and a row is taken back only where nothing points at it: nothing that landed could be taken back, and what was found to be of one nature with another stayed beside it. A record of work says what was then; it was read as if it said what is.

Rejected: Records of work passed over by name when a row is taken back (a step, a record and whatever else says what was would each be named apart, where they are of one nature); a record rewritten to leave out what was taken back (a record is what was done: what it says is not changed after); a row taken back left behind as a mark that it was (what was taken back would pile up as marks).

2026-11-16

A row entered without a name is named by its first words - and by the day before them, where the rows of its kind already kept are named so: read off what is in view, most of them. A table that asks the day of every name still says so itself.

A decision entered without a name, in a trial, came out named by its first words alone, where every decision and every reflection in view is named by the day, and no sign, connection or item is: the lens looked only for a table that asks it, and none of the language does.

Rejected: The table of decisions asking the day of every name (asked of every place that keeps decisions, it would stop the ones that named some otherwise); the day before every name (a sign, a connection, an item are not named so); a list, in the lens, of the kinds named by the day (kept by hand, where what is kept already says it).

2026-11-16

The rows a record of work touched are those remembered since the last record that are there now - and a row of a lens the place keeps as a file is there as the file has it. So what an entry changed in the language is among what its record touched, like any row.

Whether a remembered row is there was asked of the tables a place keeps, and a lens file is not one of them: the rows were remembered, and then let go. What followed a turn is read off what records touched, and the changes to the language - the ones made from within - were the ones missing from it.

Rejected: Reading them off where the record was made (that says where one stood - they were there only because the window steps onto what it makes); not asking whether a remembered row is there (a trial put back would then be said to have been touched).

2026-11-16

A saying in the window that comes to nothing leaves one standing on nothing, and says where one stood. Whatever is said next from where one stands - an act on it, an entry kept where it is held, a lens looking from it - finds nothing to act on and asks, instead of acting on a place one meant to leave. Where several entries are said at once and one is not entered, what came before it stays entered and one stands on nothing.

A part of a lens was named to be stood on and was not found; the act said next, called site/1, fell on the turn stood on before. Where one stands had stayed where the driver meant to leave: the act was right, the footing was not.

Rejected: An act naming its object in the same saying (it makes one act safe and leaves every other act from where one stands - an entry kept where it is held - as it was, with a name to type for what one already stands on); a rule for whoever drives: read each answer before the next saying (a step to remember - the window would still keep a footing one meant to leave, for whoever forgets); staying where one stood when a saying fails (where one stands is then a place one meant to leave).

2026-11-16

A site is laid out once for each language it can be read in: in the one it is written in where it always was, in each other under a folder of its tag, the same paths within - by one asking, the program laying each out afresh. The languages are read off what is in view: each one a translation is in. Each page says its language, and offers the same page in every other by that language's own name - which a place says as a row (languages), like any word.

Reading in another language was there, but a visitor could not reach it: the page said it was English whatever it was read in, and nothing led from a page to the same page in Russian.

Rejected: Every language under its own folder, the root only redirecting (every address there is would move; the language it is written in stays where it was); a list of languages kept in the program or said to the command (they are read off the translations there are); flags for languages (a flag is a country's); one program run switching languages as it goes (what was read in one would be kept for another).

2026-11-16

A star written by its shorter name is the place that goes by it, where one place in view does: a link written so is resolved like one written in full - it holds, or it points nowhere, and it ends at the thing itself. Only a link into a star that is not in view is not told.

Everything pointed at through the window - by here, by a mark, by a name as it was shown - is written by the star's shorter name, and the graph looked the star up as written: nineteen such links were neither held nor broken. Their far ends did not see them - standing on a decision, the sign that points at it was not shown - and one written wrongly would have landed unseen, by the check and by the lens alike. It was seen when the program's rule for links and the lens's were put side by side: both read the same edges, and both passed over the same ones.

Rejected: Writing links in full from the window (the shorter name is what is shown, and what a person writes); saying such links hold without looking (a link is told by what is there); every link that is not told stopping a place (a place alone does not have the others in view: what it cannot tell is not wrong).

2026-11-16

A table may say how its rows are told in a few words, as it says which field dates them: tells - one of its fields, or several laid out as a line is ({lines} lines). A thing in view says itself by those words; where its table says nothing of it, by the words a list in the program finds.

Things of thirteen kinds said nothing of themselves in a look - files, runs, work done by hand, the links of lenses kept as rows - for the few words of a thing were taken from a list of field names written in the program. Each kind knows which of its fields tells it, as it knows which dates it: read off a lens, some five hundred and seventy things stood with no words beside them.

Rejected: More names added to the program's list (the program would go on saying, kind by kind, what each kind can say of itself); the first field of a row that has words in it (a row's first field is often its id, or where it is kept).

2026-11-16

In the window a thing is stood on by its name, too: said as it was shown or as it is known - the place in full or by its star, its table, its id - one stands on it, as on what a mark marks; an entry named so is said. And the language is read again when an entry has been made in the window: what was just changed in a lens is shown as it now is, in the same look.

One stepped by marks only: a thing known by its name - a part of a lens, a decision of last week - was reached by walking to it from what happened to be shown, or not at all. And the first part of a lens changed from within was shown, right after, as it had been: the language was read once, as the program began.

Rejected: A word of its own before the name - on, at (the name is not the name of anything else: nothing has to say what it is); the language read anew at every look (it is the same until something is entered).

2026-11-16

A thing takes another name in one act, said in the window: standing on it, called and the name. Every link to it goes with it - in its own place, and in every place in view, as each wrote it, by the place's id or its star alone - and a lens kept as rows takes its parts with it. If anything would then point nowhere, nothing is renamed. What the machine keeps of itself, its trail, goes with it too, and is not landed.

The first observatory's lens commons-site became site by rewriting its rows and its parts' rows by hand, in a job: a name is what others point at, and changing it alone leaves them pointing nowhere.

Rejected: An entry's id given anew (an entry makes or changes a row found by its name: the name itself is what it is found by); a command beside move and take-back only (said from a terminal, where the window is where things are said); the old name kept beside the new one (two names for one thing, with nothing to say which is its own).

2026-11-16

A thing that is done is not held back: what holds things back holds only what is not yet done or dropped, whatever halts were drawn to it and whether or not any was said to be over. Saying a halt is over is for a halt lifted while the work it held is still ahead.

That a halt is over was asked for in words, where the work already said it: the item was done, its halt stayed, and the sheet counted it among what the author's word would free. What can be read off the work is not asked of a hand.

Rejected: Saying each such halt over by a connection (handwork after every item done - forgotten, as this one was); a part showing the halts drawn to things done (it would show what nobody needs to act on).

2026-11-16

An entry is offered only a place that keeps its kind. Where the row would be kept is the place given; else, for an entry a place brings, that place; else the place of the thing stood on - if it keeps rows of that kind, or no place does yet. Which places keep a kind is read off what they hold. Where the place one stands in keeps none, the lens says which places do, and nothing is kept until one of them is said.

A connection, entered standing in ocoeco, was offered ocoeco - which keeps none - and the entry refused it only after everything had been given. This is the first lens of the language changed in its place: looked through at once, and landed with no program built.

Rejected: Reading a place's mark for the kinds it could keep (no lens reads a mark yet; what a place holds says nearly as much, and is already in view); keeping the row in the nearest place that keeps the kind without saying so (where a row is kept is the driver's to see before it is kept).

2026-11-16

An entry writes where the row is kept. A lens a place keeps as a file is kept there - what it says of itself, and each of its parts, known by where it stands among them: a row of lenses or of lens_parts given for such a lens is written into its file, in place - what is written around it, and every comment, as it was - and what results must still be a lens, or nothing is written. A part is changed where it stands, or added after the last; a new lens is a new file, where the place keeps its lenses as files and keeps no rows of them. So a lens of the language is changed by the language's own entry - from within the window, landed like any row, and live where the language is read from its place. And what is given in the window keeps its lines: a line that names no field goes on with the field before, on a line of its own.

The language was kept by its place, but changed only by changing its files from a job: said inside, changed from outside. Rows of a lens were already read from its file wherever the language is read; this is the same way, the other way round. A lens file stays what a lens is kept as there - read as it stands, with what each part is for written above it - and is no longer a second thing, edited by hand. And the list of the language's lenses, written once more in a guard, would have stopped the first lens added so: what the language keeps is the list.

Rejected: The language turned into rows, so that the entries that already write rows would do (a lens file says more than its rows - what is written above each part - and a query kept as one long line is read by no one); a second set of entries for files (what is entered is the same row: where it is kept is the place's affair, not the driver's); the whole file written anew from its rows (every comment would go); a part named by anything but where it stands (a lens file names no part).

2026-11-16

In a field that points at things, back names where one stood before - as the word does in the window - beside here and a mark. So in one saying that enters several things, here names what was just made and back what was made before it: a sign, what came of it and the connection between them are said at once, each pointed at and none named from memory. Where here or back names nothing, the lens says so and nothing is kept.

The first act said at once - a decision and the two connections that lead to it - could point only at what was made last: a third thing had to be typed by its name. What one saying made was the one thing a saying could not point at.

Rejected: A table of what this saying made, given by the program, each thing named by its entry (one more thing for the program to give, where the steps already say it: what is made is stood on); a word for each thing made earlier - first, second (counting, where two words already known reach the three things one act mostly has).

2026-11-16

Entering is said by a lens. The lens of entering, built into the language, is looked through from an entry - by its name, or as the thing it is - and says what the entry asks and what it may also carry: which fields point at what, which values they allow, what the computer supplies; where the one looking stands and what was marked in what they were last shown - what here and a mark would name; where the row would be kept; and, given what it asks, the row it would keep - each field and its value, the name it goes by, the place it is kept in - or what is still lacking. The program reads the words given, looks through the lens, and has the entry write what the lens says: what it is to enter something is no longer said in the program. In the window an entry is said by its name or by its mark; with nothing given, the lens is what is shown.

The first piece of what the program said from outside, now said from inside: what an entry asks, how the row it makes is named, what here and a mark point at, and where the row is kept were some 170 lines of the program; they are now a lens of the language, read and changed like any other. It was tried first as a place's own lens beside the program's saying - as a language's own compiler is first run beside the one it will replace - and said what the program said, and more, since it reads the declarations themselves: what each field points at, which values it allows, what is supplied. What stays in the program is what touches a surface: reading the words given, and writing the row - which the entry does, guarding and supplying the same wherever a row is made.

Rejected: The program's own saying kept as a second way in (two sayings of one thing drift apart; the lens is built in and always in view); the lens writing the row as well (a lens looks and says, it changes nothing - writing stays with the entry); every line that begins with a word and a colon taken for a field, the lens refusing the ones it does not know (a line of the words that happens to begin so would be taken for a field); the lens kept by one place only (what it is to enter something is the same everywhere: it belongs to the language).

2026-11-16

Every kind of row a lens file keeps is written into the file by its own entry: the tables a lens defines and their fields, its entries, its links and its ways in - as what it says of itself and its parts already were. A table, a field, an entry and a way in are known by their names; a link, like a part, by where it stands. And what is given in the window may be for more than one entry: after a line that says and, and the name of an entry, what follows is for that one. Each is kept in turn, and one stands on what was made last; all that one saying entered in a place lands as one. Where one of them is not entered, what came before it stays entered, and what was not is said.

A lens file was half written by entries: a part could be changed from the window, the table it reads could not. And each thing entered was a landing of its own - minutes of checks for a few words - so that things belonging to one act, a sign and the connection that leads from it, landed as two.

Rejected: A word for what was just made in the same saying - it (one stands on what was made: here already names it for what follows); all of it taken back where one is not entered (what was entered is sound by itself: it was guarded as it was written); a row of a field or a link named by a name of its own in the file (a lens file is read as it is written: a field by its name, a link by where it stands).

2026-11-16

What repeats joins is one nature with many faces, and it comes to something as one: a sign has come to something when a connection leads from it, or from anything one with it in nature. So two things found to be one are said so by repeats, and the lenses read them as one - nothing of either is taken back.

Merging two things of one nature was to be done by taking one back, once what pointed at it pointed at the other. But the language already says what two things of one nature are - repeats joins them as one nature with many faces - and the lens of signs did not read it: a sign said again stayed showing after the one it repeats had come to something.

Rejected: Taking the one back and pointing what pointed at it at the other (what was said is consumed by the whole, not erased - and each face says the nature in its own words); a sign said again marked handled by hand (a state written, where it can be read off the act).

2026-11-16

What is in view is read in another language where rows are read: each row says, in each field a translation of its own place gives, what the translation says, and everything else as it was written. A lens is rows, so its own words - what it says, a part's heading and line - are translated the same way, by the place that keeps the lens. The language is the reader's: said once in the window (in ru), it stays beside where one stands; or given by the surroundings (OCOECO_IN) where a site is laid out. Entering is done in the words given, beside rows as written.

The page the language lays out was to be offered in Russian, as the engine's is. The engine translated where it drew a page; in the language there is one place every lens, the graph and every surface read rows from - translated there, everything is, and no lens changes.

Rejected: A second set of lenses per language (every lens kept twice, drifting); message catalogs for a lens's words beside translations for data (two forms for one nature: a word of a lens is a field of a row); translating where a surface lays a line out (the graph, a thing's few words, a page's title would each need it again); each lens asking for translations in its query (a rule for every lens to remember).

2026-11-16

The shapes a lens names are made ready each after those it asks of, wherever each stands in the lens; where none asks of another, in the order the lens gives them. So a shape added after the last may be asked of by a part that stands before it. Shapes that ask of each other in a ring are left as the lens gives them, and the engine says what it cannot make.

A lens grows by entries, and an entry adds a part after the last. A shape had to be named before whatever asks of it, so a lens could not be given a shape that parts already there would ask of - and the first lens grown this way needed one.

Rejected: A part entered at a place of its own among the parts (a part is known by where it stands: what points at the ones after it would move); the same shape written out in each part that needs it (said twice, and kept twice).

2026-11-16

That every link within a star leads somewhere is what the lens of signs says must not land: its part of links pointing nowhere stops, and the check of a place carries it with the rest. The program's own telling of links stands in where there is no engine to ask, and tells of the links into the places beside this one when they are named - until the check looks through the lenses with those places beside it too.

Put side by side, the program's rule and the lens's read the same edges of the same graph, and said the same of a link that leads nowhere: two sayings of one thing, one of them compiled into the program. The lens's is the one that is also shown as a sign.

Rejected: Both kept on where there is an engine (the same link would be said twice, and the two would drift); the program's taken away everywhere (where there is no engine to ask, nothing would tell of links at all).

2026-11-16

The check of a place is what its lenses say must not land. A part of a lens may say it stops - stops: what it shows does not hold, and a place that shows any of it does not pass its check. The check looks through every lens over the place, as it already did to see that each comes into focus, and carries each line of a part that stops, deciding nothing itself. The first such part is of the lens of signs: an id two rows go by - kept twice. What the program still holds itself - that the mark parses, that every link leads somewhere, that nothing kept out is kept, that every lens comes into focus - is moved the same way, a rule at a time, each said by a lens beside the program until both say the same.

A table is keyed by its id, and nothing held it: sixteen rows once went by three names, and the check said all was well. The rule could have been one more thing the program knows. Said by a lens it is also a sign - shown on the sheet and said aloud while it is true; it is read and changed where the language is kept; and a place can say what must not land of its own. The lens says what does not hold; the check is only where that stops a landing - as the voice is only where urgent is carried.

Rejected: The rule written into the program's check (one more thing said from outside, and seen by no lens); a lens of its own for the check (what does not fit is the lens of signs' to say - it already said a link pointing nowhere; the check is that lens, where it stops); every sign stopping a landing (a sign said by someone, or a run that fails, is shown, not a wall); moving the links at the same time (their holding has three sayings - holds, does not, not told - and the program's rule and the lens's are to be seen side by side first).

2026-11-16

The check of the language, over every place beside, looks through each lens by the name it is called from there: in full, where several places keep a lens of its name.

Once the first observatory took back the name site, the check of every lens over every place asked for site from a place that keeps neither, and was told several lenses are called so: the trial of a lens of its place had run before the two names met.

Rejected: Leaving the check to look by the name a lens is kept under (it would stop every landing of the language for as long as two places keep one name, which is now allowed).

2026-11-16

With the places beside it named, the check of a place looks through what lenses say must not land over all of them, and carries what is about this place: a link into another of them that leads nowhere is seen only so. And that nothing a place keeps holds what is kept out is said by the lens of what is kept out: its part of what is showing stops. The program's own telling stands in where there is no engine to ask - and where there is, says only what no lens says yet: a link into a star that is not among the places in view. What the check still says itself is reading: that a place has a mark, that its tables are there and are rows - and that each lens comes into focus.

The third and fourth rule moved as the first two did: each time the program's telling and a lens's part read the same rows. A part that stops says the thing each of its lines is about, so that with other places in view the check carries only what is this place's - one place's sign does not stop another.

Rejected: Every line shown with the places beside it carried (a place would be stopped by its neighbour's sign); a link into a star that is not in view stopping by a lens (from a place alone every link into another star is so: not told is not wrong - the program says it only where the places are beside it); what is kept out left to the program because it guards secrets (the lens already said it, urgently, wherever it showed: the check only carries it).

2026-11-16

The language is kept by its place. Where the place that keeps the language - in a folder called language, holding the lens called language - is in view from where one looks, and is not behind the program, its lenses are the language: each as it is kept there, as it is now. A lens changed there is changed - looked through at once, with no program built anew; a lens no longer kept there is gone. The program carries a copy, as it was when it was built, and looks through that everywhere else: where the place is not in view, where the program that place builds is older than this one, and - all of it - where what the place keeps is not sound as a whole. A lens kept there whose text is no lens yet stands as the program carries it.

Moving entering inside took four releases of the program, each to change what one lens says: the language was said inside, but could only be changed from outside. The program already treats the words of the language so - it carries them as they were when it was built, and over them the words of the places in view. Read from its place, a lens of the language is changed like any other thing a place keeps, and the program becomes what answers, reads and writes - with a copy of the language for where its place is not. It is the step after the first translator: the language's own saying is no longer inside the thing that runs it.

Rejected: The place's copy always winning (a clone left behind would put an older language over a newer program: the program the place builds says which is older, and nothing has to be stated by hand); a version written into each lens (a thing to remember at every change); the language read as it last landed rather than as it is now (what a place keeps is in view as it is now, like its rows and its own lenses - and trying a change before it lands is the point); half of each where what is kept is unsound (a language is one whole).

2026-11-16

The language is read as its place keeps it wherever that place is held on the machine one looks from: among the places in view, and else where the machine says it is held (OCOECO_LANGUAGE). So a place's own check, made where it is held, reads the language as it is kept - with what was changed from the window - and not only as the program carries it.

A part was taken back where only records pointed at it: from the observatory nothing pointed nowhere, and from the place's own folder two links did - there the language was the one the program carries, older than what had been changed from the window. A place is checked where it is held, so what it was checked with hung on where one stood.

Rejected: Each change made from the window released at once (minutes of building for a few words - and the lab would still look through the program it has); a place's check made from the observatory (a place is checked by itself, where it is held); the language's place looked for among the folders around (where it is held is the machine's to say, not to be guessed).

2026-11-16

The language being read is a given of every look, as today is ({in}), and the languages there are, are what a lens says (reading): any lens may ask of it, and each surface - a page, the window - says its own offer of them under its own constraints. The program writes no page's words: laying a site out, it hands a page only what a page alone cannot know - where it is written, and the way up to where the site in every language rests - and asks the lens which languages to lay it out in.

The author, the same hour: a page is one surface a lens of lenses can project onto; the ecosystem is the main vector. The program had just been made to write a page's offer of languages itself, and to keep its own list of them - the page first, the whole after.

Rejected: The offer written by the program for the page (one surface served, by words outside the language - landed an hour before, and taken back here); a list of languages the program reads off by itself (a second saying beside the lens's); the language written in named in the program (it is a fact of the whole: a row says it).

2026-11-16

How the latest run of each workflow of a place ended is kept once: as runs, observed of every place by the observatory. The gatherer no longer writes it into each place as ci, the folder it writes is what it gathered that time, and the engine's page reads the runs.

It was kept two ways - ci, gathered by each place's own gatherer once a day, and runs, observed of every place every quarter of an hour: one nature in two tables, of which only runs was declared by a lens and read by the lenses, the sheet and the voice. The engine's page alone read ci.

Rejected: Declaring ci beside runs (the overlap made official); runs gathered by each place in place of observed (once a day, where the sheet and the voice ask every quarter of an hour).

2026-11-16

The one language is seen through a lens of its own (one-language): each form a word names, and how each overlay words it - English one overlay among the others; how much of the language each overlay words; where an overlay words several forms alike, the forms meeting in one word; where an overlay has no word for a form, a gap; and the forms no overlay has a word for at all. It is made of rows that were already there - the words, their wordings in overlays, the overlays - and changes nothing in the program.

The author, 2026-11-16: there is only one language, and English is an overlay in it; ocoeco, a language intelligent about itself, would show where overlays overlap and where no overlay has a name. The language already kept forms and their wordings - only no lens looked at them as one.

Rejected: Making English a second table beside the forms first (a move of every word for a frame not yet seen through a lens: the lens first, then what it shows the rows want); one lens per overlay (an overlay is a face of one language, not a language of its own); counting a form unworded only where every overlay lacks it (a gap is of an overlay, and a form no overlay words is its own deeper gap - both are shown).

2026-11-16

In the window, what a lens places is laid out one step up - its name, what it says of itself, its headings - and one says its name to look through it. But a lens that only places one lens has nothing else to show, and what it places may have no name of its own to be looked through by - a lens seen through the lens behind it: there the window lays out the lines too. And a link pointing nowhere is a line about the row it is written in: it is marked, and one stands on that row to set it right.

What waits on the author - the sheet, seen through the lens behind it - showed in the window as a heading with a count, and no way to the six lines it counted: the first lens made by adding was the one lens the window could not show. Changed in the language's own place, and looked through at once.

Rejected: Every placed lens laid out in full (the front would be the whole page at every step up: the window is for moving, and a step shows where one is); a name given to every lens seen through another (the arrangement is the lens that places them - that is its name).

2026-11-16

What entries add to a lens file is written as the language's files are: each new table, part, link, entry and way in apart from what is before it by an empty line, and what a table says of itself before its fields.

The first lens of the language made wholly from the window, gathered, came out with no empty line between its tables and a table's words after its fields: it said the same as a lens written by hand, and read closer.

Rejected: The file laid out anew after each entry (what is written around a row, comments among it, would be lost); leaving the spacing to whoever opens the file (a file made from the window is read in the window and by hand alike).

2026-11-16

Where an entry is shown, of what was marked in what was last shown only what fits is offered: each thing with the fields of the entry that can point at a thing of its kind - and the thing one stands on says which fields here fits. An entry none of whose fields point at things is offered nothing. And a thing is given one mark, by whichever of its names a line says it.

Shown through the lens, the entry of a source listed twenty-three marked things, none of which it could point at; and a research showed one thing under two marks - by its whole name and by its shorter one. Offering is choosing in place of typing only where what is offered can be chosen. Which fields point at what is declared, so the lens reads it: nothing of it is worked out in the program.

Rejected: All that was marked listed for every entry (most of it fits nothing, and what fits is lost among it); the fitting worked out in the program (it is in the declarations: the lens reads them); a mark for each name of a thing (two marks for one thing say there are two).

2026-11-16

What the gatherer writes of each place is declared by a lens of the language, gathered: its activity day by day and its releases - what a row of each is, how it is told, and when it was. So what is gathered says itself in a look, like anything a place keeps.

The gatherer writes activity, releases and the latest runs into every place, and no lens declared them: what was gathered said nothing of itself in a look, and nothing said what its rows are.

Rejected: The latest runs declared beside them (they are of one nature with what the observatory observes as runs - a sign of its own); what the gatherer writes left undeclared, as rows the program makes (what a place keeps is said by a lens, whoever writes it).

2026-11-16

What the gatherer writes, and where - its two tables, the folder and the branch - is said once, in the program where it writes them; every mark keeps those tables without naming them, a mark that names one elsewhere keeps it where it says, and a place the gatherer does not gather simply has none of them to read. Where only a checkout of a place is in view, its call to the gatherer says it is gathered. The gatherer's workflow no longer takes another folder or branch: no caller gave one, and none would be read.

Nineteen marks named the same two tables by the same paths: one fact said nineteen times, so the gatherer writing one table less took nineteen landings. And two places that call the gatherer named nothing of it: what was gathered of them was never read.

Rejected: A line in each mark saying it is gathered (one fact still said in every place); the lens of what is gathered saying where its tables are kept (the writer says where it writes - a lens saying it too would be a second saying, free to drift); the caller's file read wherever a mark is read (what the gatherer wrote is the act itself: where none was written there is nothing to read).

2026-11-16

A mark may say holds = [places]: the places whose records it keeps in its own tables. When it is gathered, a row whose project names one of them stays theirs; every other row is the place's own, as before.

The author decided on 2026-11-17 that linux-phone-oco keeps one database for the whole project (linux-phone-oco/docs, through tad), with a project column: the records of lab-tools, surya-lab, device-template and sxmo-deviceprofiles move there. Each record must still show as of its place on the face, as it did when each kept its own tables. Nothing changes for a mark that does not say holds.

Rejected: Tagging every row with the project of the place it was read from even when the row names another (the face would show every moved record as docs'); keeping any row's own project whatever it names (a place could speak for places that never gave it their records); re-attributing rows in the engine instead of the harvest (one nature - which place a row is of - would be decided in two places).

2026-11-17