Open Commons ObservatoryEnglish·Русский

Concepts and decisions

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

A job is a record with a journal

A job's life is journalled - submitted, claimed with a lease, heartbeats, steps done, finished, parked - and the journal is the only truth; nothing is inferred from a missing file. Built 2026-11-12 in oco-agent/core: what may follow what in a job's journal is one function, so a finished, expired or parked job cannot be claimed - run once by construction.

A voice of its own

The agent's heartbeat is watched from outside the machine, and the client can raise an alarm without the agent.

Coordination for any driver

ocoeco is the memory and the language of the work; oco-agent is how work is coordinated: it takes work, does it, journals it, and talks with whoever drives it - people and machines alike, each through what suits them (a terminal interface for people, the phone, the command line for machines). It reads and writes ocoeco's shared tables instead of keeping a parallel set, and depends on ocoeco, never the reverse.

Jobs that do not conflict run side by side

A job declares the resources it holds - the phone, a repository, the build machine; jobs that share none run in parallel, so work goes on while a phone reboots or a kernel builds.

Resume, never replay

Work is a flow of idempotent steps, each journalled when done; after any interruption the flow resumes at its next step, and a finished job never starts again.

The driver's lease

Each driver holds a lease of its own, renewed by beats its client sends while it works; a job starts only while the driver who asked for it is still there. When a driver falls silent, its waiting work waits, others' work goes on, and what is running reaches its end.

Waits are measured where they happen

Every submit --wait and every wait records itself: what was waited on (a build, a reboot, CI, a harvest), for which project, how long. Gathered into each project's data like commits - made by the work, never typed.

lab-agent is delivered by the package conveyor (linux-package-distribution-oco/conveyor@v1); it keeps only its declaration, build scripts, PKGBUILD, public key and install test.

Its delivery workflows were a near copy of snapall's; copies drift and fixes do not travel.

Rejected: Keeping its own copy of the delivery machinery.

2026-11-11

lab-agent records each wait itself - start, end, what is waited on, the project - and requires both on a waiting submit; a gatherer brings the waits into each project's data.

Capture must be unavoidable and cost nothing: the place every wait happens is lab-agent's own wait.

Rejected: Logging waits by hand (it would be skipped); estimating them afterwards.

2026-11-11

Every process a job starts carries the job's mark in its environment (OCO_AGENT_JOB). When the job ends, overstays, or was left by a run that died, everything carrying its mark is ended - asked to stop first, then made to. Something meant to outlive a job is started as a service, not as its child.

Crash-only cleanup must not trust the runner to have lived: a dead run's jobs are found by their mark and cleared before anything else happens. The mark reaches children's children, which nothing else here does.

Rejected: Process groups (a child can leave its group); a death signal to children (it reaches only the direct child); systemd's control group alone (tests, and machines without it, would have nothing; it still helps where present).

2026-11-12

Work is asked for through the jobs repository as files under oco-agent/jobs - apart from lab-agent's jobs/, so during the switch neither agent takes the other's work. A file's top line says who asked, when and its limits, and counts only at the top. When work was asked comes from the asking, never from when it is read. Drivers' beats are the repository's Actions variables. Only oco-agent-github knows GitHub.

An agent that was down must not see old work as new: the asking's own time makes such work expire instead of run (the quieter cousin of the 2026-11-11 replay). A header read anywhere is how lab-agent's client lost a line from inside a script. A beat every few minutes as a commit would fill the history with hundreds of meaningless commits a day.

Rejected: Taking the moment of reading as the moment of asking; a header read anywhere in the script; a separate metadata file beside each script (two writes, and a window with one but not the other); beats as commits; a second repository for oco-agent's jobs (the same trust and the same token, twice the setup).

2026-11-12

oco-agent is built inside lab-agent's repository (oco-agent/), tested by its CI and kept out of its releases, until it takes over and the repository takes its name.

Its design, research and backlog already live here; lab-agent must keep serving while it is proven; tad's Rust version grew the same way.

Rejected: A new repository now (the reasoning and the code would live apart, and the history would split).

2026-11-12

Each driver - a person or a machine - has a lease of its own, kept alive by its beats: a job starts only while the driver who asked for it is still there. Beats are what is known now, not a history: one fact per driver, a newer beat replacing an older and never the reverse; they are kept apart from the journal, behind their own port, with their own check in the measure.

oco-agent coordinates work for any driver; one driver going silent must not stop another's work, and must stop its own. Beats arrive often and only the latest matters, so they are state, where the journal is history.

Rejected: One lease for 'the' driver (the first design: a silent AI would have stopped the author's work too); beats as journal entries (hundreds of lines a day that say nothing after the next one).

2026-11-12

The redesigned lab-agent is oco-agent: born beside lab-agent, which serves until the switch - as tad's Rust version grew beside the Python one - then lab-agent retires.

The author, 2026-11-12: it is tied to ocoeco by design. 'agent' is the established word for this role; 'oco-' names its family and its dependency on ocoeco.

Rejected: runner (GitHub's word - true, but it says nothing of the voice, the journal or the leases); keeping lab-agent (it names a place, not what it belongs to); renaming in place (the old one must keep serving until the new one is proven).

2026-11-11

lab-agent's core speaks its own language and depends on nothing outside itself (a crate with no input or output); every technology - git and GitHub, ntfy, systemd - is an adapter behind a port the core defines, and its words appear nowhere above it; areas are named for what lab-agent is for; the playbook's guards check it on every change; in-memory adapters run the chaos tests. The journal is declared tad tables queried with SQL, and where they live is itself an adapter; finished work becomes glimpses. The journal's SQL is tad's, and tad's SQL is DuckDB's (tad-engine 2026-11-12-sql-is-duckdb), as tad's original research decided.

The author, 2026-11-12: follow the ideal-project guidelines; the implementation must not rely on GitHub - it is today's adapter, and switching it (to Redis, say) must be a clean replacement; git as a heap of files is a one-off mess when tad is a database and ocoeco makes every action intelligible.

Rejected: A core that calls GitHub and git directly (the prototype's way, and the root of the incident's reach); folders named ports and adapters (the playbook: names say what the program is for); the journal as files in a repository with no declaration.

2026-11-11

oco-agent is trusted with nothing until it has watched lab-agent: a shadow run reads lab-agent's newest log every ten minutes through oco-agent's rules, keeps its own journal, and alerts urgently when lab-agent starts work oco-agent would have refused. It decides; it never acts.

Rules proven on tests and on one night's log should also hold on the days that follow, before they run anything; and lab-agent is still the one running jobs, so a replay there must be noticed at once.

Rejected: Switching to oco-agent at once (proven only on the past); a daily report (a replay storm ran 102 jobs in twenty minutes on 2026-11-11).

2026-11-12

What happened is spoken back to the repository work was asked through, on a branch of its own (spoken): the journal, and each job's log. It is written only when something changed - the journal at most every ten seconds, a running job's log at most every minute, a finished job's log at once - logs before the journal, so a driver who reads that a job ended finds its log there. Only jobs the running agent did are spoken. A driver anywhere uses standing, log and wait with --via; waiting is a beat, and wait's exit status says how the job ended (0 finished, 1 failed, 124 out of time, 3 expired, 4 parked, 2 not ended yet).

A driver must see how work went from wherever it drives, as with lab-agent's results - but in the one repository it asked through. The history of asking stays readable on main. Writing only on change keeps within GitHub's limits on content creation as well as its hourly budget.

Rejected: A second repository for results, as lab-agent has (two places for a driver to look, twice the setup); writing on main (the asking history drowned in reports); writing every change at once (commits by the second); speaking every log in the folder when a runner starts (a burst after each restart).

2026-11-12

Everything that polls GitHub asks conditionally (ETag), so an unchanged answer costs nothing; oco-agent reads what is left of the hour's budget from every answer and, below 500, takes work in only every 2 minutes, saying so once. Writing - commits, variables - happens only when something changed.

The 5,000-an-hour budget is shared by everything on the account; one careless poller can starve land, the client and the pin updater together. lab-agent had learned this; the redesign must carry it over, not lose it.

Rejected: Polling without conditions (about 480 an hour for intake alone); a fixed slower interval (slow even when the budget is plentiful); a second account or token for the agent (two secrets to keep and rotate, and the token is to be rotated already).

2026-11-12

oco-agent does work through Hands - start, look, stop, clear - whatever actually runs a job (processes on this machine today). A job is claimed in the journal before it starts, and does not start if the claim is refused; its end is written as it happens, and an end that could not be written is kept and written at the next step. Each job says how long it may run and is stopped if it overstays. A run of the agent is numbered by the moment it began, to the millisecond.

The replay of 2026-11-11 came from work whose record lived apart from the doing; here nothing starts unrecorded. Deciding needs only that no two runs share a number, so a moment serves where a counter would be more state to keep right.

Rejected: Starting first and writing after (a crash between the two leaves a job run and unrecorded); a counter of runs kept on disk; retrying a job that could not start (it would fail the same way, repeatedly).

2026-11-12

The lab is watched by a dead man's switch outside GitHub: oco-agent sends its pulse to it (OCO_AGENT_PULSE_URL, or a private file ~/.config/oco-agent/pulse-url) after each healthy turn of its loop, at most every five minutes; when pulses stop the switch alerts the author through ntfy. The watcher workflow stays as a second, probing check where GitHub's schedules fire. Lives since 2026-11-12 09:44 UTC: pulses every five minutes, the check up.

GitHub's schedules proved unreliable on this account: the watcher had no scheduled run at all, in a private repository and then a public one, and lab-agent's daily gather has run by schedule once in two days, hours late. A pulse from the working loop stops for every failure that matters - the machine, its network, an agent that stalls - and needs no clock of our own.

Rejected: Trusting GitHub's schedule (it fired not at all); a timer on the lab sending the pulse (blind to an agent that stalls while the machine runs); the lab dispatching the watcher (silent exactly when the lab is down); an outside cron calling the watcher (two moving parts where one does).

2026-11-12

The lab's watcher is its pulse, received outside by Healthchecks: when the pulse stops, Healthchecks alerts. The GitHub workflow keeps the probe of the whole path, run by hand, and loses its schedule.

GitHub's schedules are best-effort and drop silently (research the-watcher-that-did-not-watch); a watcher that is silent when it fails is the failure this lab keeps meeting. The pulse is proven, and depends on nothing the lab runs.

Rejected: Keeping the schedule as a second watcher (it would look like watching while not watching); a scheduler of our own elsewhere to dispatch the workflow (one more service to watch, where Healthchecks already does it); moving the schedule to another repository (the first move did not help - it is GitHub's clock, not the place).

2026-11-12

lab-agent is redesigned around a journal per job, run-once by construction, the driver's lease with park-on-silence, each job's heartbeat, flows of idempotent steps that resume, a working tree per job and side-by-side by resource, crash-only recovery, a watcher outside the machine, secrets kept out of URLs, and its data flowing through ocoeco - in five stages, each proven by chaos tests before the next (DESIGN.md). Refined the same day by 2026-11-12-ports-names-and-tables: ports and adapters with the playbook's names and guards, and the journal as tad tables queried with SQL.

The 2026-11-11 incident traced to a foundation laid as a one-off prototype; the author asked for the best the world has learned, with the full picture in mind.

Rejected: Patching the replay and carrying on (the other paths stay open); adopting a durable-execution engine such as Temporal or Restate (a server to run and secure on one machine with no inbound port - lab-agent takes their proven ideas into a small core instead, with git as the record it already has).

2026-11-11

oco-agent takes over the running of jobs step by step, each with a way back (DESIGN.md, The switch): it serves beside lab-agent; its client ships in lab-agent's release; drivers move, the AI first; the watcher probes it; and only when it has a voice of its own does lab-agent's daemon stop. Until then lab-agent's daemon keeps running - it carries the author's notifications and the board pushed to the phone - and is simply no longer asked to run jobs. oco-agent's service keeps the lab awake while it serves.

Live work, the author's phone flows, the probes and the shadow all depend on what runs today; each step must be provable and reversible on its own. The daemon's voice was found by reading it before planning to stop it.

Rejected: Stopping lab-agent's daemon now (the author's notifications and board pushes would stop without a word); moving everything at once (nothing to fall back to); letting the lab sleep when idle (it is set to suspend after an hour: it would take no work and look silent to the watcher).

2026-11-12

Drivers say things to one another (oco-agent say, inbox); what is said is a tad table beside the journal. A driver with a channel on this machine has it carried to their phone through ntfy - urgent words on the urgent topic - and what they answer on their own topic is heard as something they said to everyone. How each job of such a driver ended is said to them once, with its last lines. The topics live in a private file on the machine; a voice that fails rests five minutes.

It carries what lab-agent's voice had learned: two channels, so the phone can let urgent ring through; the topics' names are the secret and never leave the machine, so whoever speaks never needs them; a failed send waits, since the server counts by the day. And it is simpler: the author is a driver like any other, so one table and one way serve notifications, replies and talk between drivers.

Rejected: Notifications as a thing apart from what drivers say (two mechanisms for one act); telling the author how every job ended (hundreds a day: only a reachable driver's own jobs - others say what matters themselves); trying a failed send again every turn; the board in this step (next: most likely the items in progress in ocoeco's data, not a list of its own).

2026-11-12

The watcher runs in this public repository (.github/workflows/watch-the-lab.yml), probes oco-agent instead of lab-agent - asking through the jobs repository as the driver 'watcher' and reading the answer from what oco-agent speaks - and counts any end of a probe as an answer. It keeps only the newest probes. Every GitHub listing oco-agent relies on is read from the git tree, and a listing cut short stops the taking-in instead of passing in silence.

In the private jobs repository GitHub never ran the watcher's schedule (0 scheduled runs, while this account's public repositories ran theirs - the observatory's at 07:10 that morning); a watcher that can stop without anyone noticing is the gap it was built to close. lab-agent is disabled after replaying; oco-agent does the work now. A listing that silently stops at 1,000 caused both replays.

Rejected: Keeping the watcher in the private repository and nudging its schedule (no way to see whether GitHub registered it); an outside cron service now (another account to create - kept as the watcher's own guard, see watch-the-watcher); listing with the contents API (silently cut at 1,000).

2026-11-12

The lab is watched from outside by probing it: a workflow in the jobs repository asks a tiny job every half hour and alerts the urgent channel itself - once - when the lab has not answered for 45 minutes; it says so when the lab answers again, and asks no new probe while one is unanswered. It needs no secret beyond the channels: the probe writes its answer back into the same repository with the lab's own token.

On 2026-11-11 the agent stalled while the machine was on, and the only alert path ran through the agent. A beat from a timer would have stayed happy through the stall; only work actually done proves the agent takes work (black-box probing). Watching from GitHub keeps the alert independent of the lab.

Rejected: A timer on the lab sending beats (blind to an agent that stalls while the machine runs); a hosted dead man's switch such as Healthchecks (one more account, and still fed by the lab); a probe every few minutes (noise in the jobs repository, and a long job would look like silence).

2026-11-12

The first part of a place's id says where it is held. For oco-agent's record that is the machine, written so that it cannot be taken for an owner elsewhere, and the place is named for the program whose record it is: MACHINE.local/oco-agent.

Set right the same day it was made: the mark was first written as USER/MACHINE, read off the surroundings - but across the commons the first part of an id is who holds the place, and until now that was always an owner on GitHub. mll/grig said an owner called mll holds it; that is not so, and there is such a person, with repositories of their own. Looked at before choosing: an observatory keeps what it discovers and gathers, it does not go through an owner's repositories - so the harm was small; the name was still untrue.

Rejected: The user as the first part (it names an owner elsewhere); a setting for what the place is called (the machine and the program are there to be read); an id that says nothing of where the place is held (every other id does).

2026-11-13

oco-agent's record says what it is, in the commons' way: the folder is a place (a mark, written where there is none - whose and which machine read off the surroundings; a mark a person wrote stands) that brings the lens of now, kept beside the mark. The lens is the declaration of the tables itself with what it brings into focus added - one declaration, so it cannot say other than what is kept: what is being done now and for whom, what is asked and not yet begun, what was cut off, who is here. The journal adapter writes both when it opens the folder.

The record has been tad tables declared in the language a lens declares tables in since 12 November, and nothing read them: ocoeco could look only through lenses built into it. Since 2026-11-13 a place brings its own lens (open-commons-observatory/ocoeco, decision 2026-11-13-a-place-brings-its-lens); tried that day with a mark and a lens put on the lab by hand, what is being done came into focus to the minute, typed by nobody. They are oco-agent's own to write: put there by hand they would be gone with a reinstall.

Rejected: The lab's tables written into ocoeco's lenses (ocoeco would know oco-agent); a setting for which place this is (whose and which machine are there to be read); a lens kept apart from the declaration (two that can disagree).

2026-11-13

What oco-agent's record is travels with its rows. The agent speaks its mark beside the journal; and what a repository spoke is kept, on the machine that reads it, with the programs' own data - a folder for each repository, holding the mark that was spoken, the journal, and the declaration and lens the adapter writes. So the copy is that place: it can be stood in and looked through, and is in view from an observatory there. Where no mark was spoken the copy says nothing of what it is.

The author, 2026-11-13: for looking from somewhere else we have the answer at our fingertips - making somewhere else into somewhere here. Looked at: it was already so. The journal has been spoken row by row since 12 November, and a command told to read through the repository has fetched it into a copy opened by the same adapter. But the copy was a temporary folder named by a process number, thrown away; nothing spoke the mark; and since the adapter began writing a mark from its surroundings, a copy would have named itself for the machine it arrived on. The mark is the one thing that cannot be read off where a place arrives.

Rejected: A second layout for what is spoken (the copy is laid out as the record is); speaking the declaration and the lens too (the adapter that reads the copy writes them, as on the lab); a copy that names itself for where it is (untrue: it is the lab's record, brought here).

2026-11-13

A driver speaks with git alone where that is all its workspace lets it do. What a driver needs is to read one repository and to put a file in it. An asking is said as its file under oco-agent/jobs - through GitHub's API where it takes the write, otherwise by a push. The asking is itself a beat: the lab counts it as one when it takes the work in. While a job waits unstarted, its driver says it is still here a third of a lease apart - as a variable where the repository's Actions can be written, otherwise as a small file under oco-agent/beats, pushed - and the lab hears both. What a workspace needs for this is kept here: driver-setup builds the client from this repository, and no token of the lab's is copied into a sandbox.

On 2026-11-15 the driver's workspace changed under it, and the lab's one way in was gone. Looked at before replacing: beats were made variables on 2026-11-12 so that a beat every few minutes would not fill the history with commits. That stands, and variables remain the first way. But an asking already says who asked and when, so the beat written beside every asking said the same thing twice; and a waiting driver beat every minute, though a lease matters only until its job starts. With the asking counted as a beat, and beats said only while a job waits, a driver who speaks with git writes one commit for an asking and almost never one for a beat.

Rejected: The lab's token in the driver's sandbox (it can do far more than a driver needs, a sandbox is not kept, and the new workspace does not let it out); a way around the workspace's own way out (refused there, and not tried); beats as commits for every driver (the reason of 2026-11-12 holds); a branch of its own for beats (one more thing to hear, for what now seldom happens); telling a refusal by the words of the answer (it is told from a spent budget by what GitHub says is left).

2026-11-15

What every job that works on the ecosystem does is said once, in oco-work, which a job sources: a place brought to a new branch, an exact text changed, a thing stood on, an entry made, the Rust of a place checked, a program tried and put back if the job stops, looks kept and compared, a place landed, a release merged, a turn entered. A change to a file is sent as the text that changes, not as the file. A summary too long to be a title stops the job before anything is recorded. From a sandbox, ask sends a job and follows it.

The author asks that repeated handwork be automated without waiting, and that tokens be saved. Sign every-job-says-again-what-every-job-does. Each word of oco-work is something that was typed again in job after job through 2026-11-11 to 15, and each of its refusals is something that went otherwise by hand.

Rejected: A program for it (these are a few lines each around tools that exist: ocoeco, land, swap, cargo, gh - and no new Python); leaving each job to say it (it was, some two hundred times); words for what only one job does (a word is for what the next job will do too).

2026-11-15

A job shows files to the driver who asked, and the driver brings them: shown FILE, a word of oco-work, puts a page or a screenshot made on the lab on the branch shots of the jobs repository; brought NAME, a tool beside ask on the driver's side, fetches it from there by its name. A page made on the lab is then looked at where the driver is - at any width, in the dark, with a fold opened - as often as needed.

On 2026-11-15 six jobs each carried the same eight lines to put screenshots where the driver could fetch them, and the driver fetched each with a line typed again: handwork repeated, and the driver's half of it kept nowhere - on the day a workspace was replaced and what was kept nowhere was lost. And a look took a job each time: one for each width, each part of a long page. The page itself, brought once, shows all of that.

Rejected: A screenshot for every look (a job and minutes for each, and what is seen is only what was asked for beforehand); another way between the lab and a driver than the jobs repository (it is the one way they already share, and a driver's workspace is let read it); the token named on a command line to fetch with (it is read from where it is kept and handed over out of sight of the list of what runs).

2026-11-15

Two things every session did by hand are words of a job. turn ID AFTER AT TEXT [SAID] enters the author's turn as it was said, with the moment it was said, and stops where the conversation's place does not hold with it. settled REPO WORKFLOW waits until none of a workflow's runs is under way and says how the latest ended.

On 2026-11-15 each turn was entered by six lines written again in each job - the word for it carried no moment and went on where the entry failed - and a wait for a harvest or an observing to end was written three times, each a little differently; one of them took a run that had been cancelled for the one that mattered. The lens of results had counted watching a run by hand nine times before that day.

Rejected: A wait inside each job that needs one (the same loop, written again, is how one came to watch the wrong run); a turn entered without its moment (when a thing was said is part of what was said).

2026-11-15

The word released says a release only once it can be taken: after its pull request is merged it waits until the new release is there with its files - as many as the release before it had - and brings the place held to its main, so that a look over the places held sees the release. And a place that takes what is entered straight on its main - the conversation - has a word for it: straight checks, records, commits and pushes the place as it stands, after fresh PLACE main.

On 2026-11-15 a job waited for a release's files with a loop written in it, and the next job needed the same loop; a look over the places held said nothing had been released after a release was, for the place held stood where its change had landed, one change behind; and the lens of what followed was kept in the conversation's place by lines written out in the job, as each turn once was. What is written again in each job is a word of a job.

Rejected: Waiting a fixed time (a release's files take as long as they take); leaving the place held where it stood (what is held is what a look reads: it would go on saying the release had not happened); a pull request for each row the conversation takes (it has no checks of its own to wait for - the check is made before the push, where the row is entered).

2026-11-15

A driver without a terminal has the window through two small things. window, on its own side, carries what it says - a mark, a lens, an entry by its name with what it asks beneath - to the lab, and brings back what is shown. said, a word of a job, says it in the window there and lands what was entered, in the place the window says it was kept in. Neither knows what the words mean.

The author, 2026-11-15: an interface one stands in and acts from, not commands with flags held in one's context. The window is ocoeco's; what a driver elsewhere needs is only that its words are carried there, and that what it enters lands as every change does.

Rejected: A job written out for each look and each entry (what the agent had been doing: the way in remembered from outside); landing left to the driver (an entry kept and not landed is seen by no one else, and holds the place it is in).

2026-11-15

Landing the language's place, where what lands changes the language, is checked with the places beside it: every lens they keep comes into focus with the language as it would land.

A change to the language made from the window landed checked in the language's place alone, and stopped the conversation's lens of what followed - seen only at the end of the turn.

Rejected: Every landing of the language's place checked with the places beside it (each would take longer, where most change no lens).

2026-11-16

A job's trail is its own: what a job stands on says where its work was made, and is no step of the driver who asked for it. It is kept in a trail of the job's, read by the record of its work, and left with the job. The window, said within a job, is the driver's own act: it steps where the driver stands, and what it enters lands with where the driver stood.

A job stood on things to say where its work was made, in the trail of the driver who asked for it: after each job the driver stood in the window where the job had stood, and what was said next was looked through from a thing of the job's. One trail carried two acts - where the driver looks, and where a job says it worked.

Rejected: A job standing as a driver of another name (the record of its work would then be by another); where a job worked given to its record in words (where work was made is read off the act of standing, as it is in the window); the driver standing again after each job where they stood before (a step taken to undo a step).

2026-11-16

Every job says where the language's place is held on the lab, so that every look and check it makes - a place's own check among them - reads the language as its place keeps it.

A place is checked where it is held, and from there the language's place is not in view: its check read the language the program carries, older than what had been changed from the window.

Rejected: Each place made to have the language's place in view (a place's mark says what it is, not where the lab keeps the language).

2026-11-16

Landing the place that keeps the words every job uses puts them to use: where what landed differs from what is in use, it takes its place, and the next job begins with it. The job that landed them goes on with the words it began with.

A job that changed the words put them to use by a line of its own, each time - until one did not, and a saying was carried by the words from before: half of what it entered stayed unlanded. What is done after every landing of that place belongs to the landing.

Rejected: The words in use being the place's own file, linked (a job at work in that place would be working with words not yet landed); every job looking, as it begins, whether the words have changed (a look each time, for what changes only when that place lands).

2026-11-16

What is said in the window may enter more than one thing; the word that carries it lands all that one saying entered in a place as one landing, named by the first and saying how many more.

A sign and the connection that leads from it are one act; landed as two they were two rounds of checks, and a moment in between when one was there without the other.

Rejected: One landing for all the places a saying entered in (a landing is a place's own: each place is checked and landed by itself).

2026-11-16

landit checks a place kept by tad (tables.toml beside its data) with tad alone - tad check, then make verify where its Makefile has it, as its CI does - and commits it without a glimpse; ocoeco check and glimpses stay only for places without tables.toml.

The author, 2026-11-17: our systems must not depend on ocoeco. landit ran ocoeco check in every place, linux-phone's and ideal-agent's included, so a tad place's own rules were overruled by ocoeco's lens: ideal-agent's about values were refused until ocoeco's reasoning lens was changed (ocoeco #458) - the dependency the author named.

Rejected: Keeping ocoeco check beside tad's in tad places (ocoeco's lens would still decide what a tad base may hold); detecting tad places by a missing glimpses export (a tad place may still export to the observatory; tables.toml is what makes it tad's).

2026-11-17

The shared skills of oco-agent/skills (lab-session-start, land-a-change, change-the-phone, record-the-work) and the practices lab-agent guide reads move to grenudi/ideal-agent: the skills ship in its Claude Code plugin (change-the-phone's general part as change-a-device; its devlab part stays in linux-phone-oco), and guide reads the practices live from ideal-agent's database (data/practices.json), its built-in copy refreshed from there. oco-agent/skills keeps only a README pointing there; the lab's ~/.claude/skills links are removed once the plugin's skills are proven.

The author, 2026-11-17: one repository, grenudi/ideal-agent, is the one home of general agent know-how (its decision 2026-11-17-one-home-for-agent-know-how). Linked from this clone into one machine's ~/.claude/skills the skills reached no other machine or cloud session; the plugin installs them anywhere. This carries forward 2026-11-17-skills-shared-by-every-agent: procedures kept once, as skills.

Rejected: Keeping the skills here and linking ideal-agent to them (two homes for one thing); a copy in both places (copies drift).

2026-11-17

The procedures every agent on the lab follows are kept once, as Claude Code skills in oco-agent/skills (lab-session-start, land-a-change, change-the-phone, record-the-work), linked into the lab's ~/.claude/skills so every session finds them when the work calls for them; they point to oco-work's words and carry the traps met.

Read in ArtCraft's organisation (craft-skills): procedures shared as agent skills, discoverable rather than remembered. On 2026-11-17 four sessions worked on the lab at once, and the same traps cost time more than once: a clone reset by fresh took unlanded files, docs' rendered pages lagged a row entered after rendering, land merged a release PR from a shell without oco-work.

Rejected: Each brief repeating the procedures (copies drift, and a brief is read once at the start); a separate skills repository (one more place for what oco-agent already is - how agents work on the lab).

2026-11-17