Open Commons ObservatoryEnglish·Русский
Linux PhonesEssenceThe ideaHow close we areThe phone in the labFeaturesDevicesSoC familiesTestsResearchDecisionsBacklogThe phone's queueLandscapeMade by work

Decisions

What the work rests on, and each decision: why, and what was rejected.

As good as Android

A phone running Linux that an ordinary person could use as their only phone and not feel they gave something up - counted one feature at a time.

Why: The aim is plain and counted against Android's everyday use (the idea, section 05); without a measure it would be a hope.

Mainline first, everything upstream

Work is done on mainline Linux and written to be sent upstream: each fix its own series, checkpatch-clean, to the upstream it belongs to; vendor code is read as a specification, never copied.

Why: A fix kept in a fork helps one phone; a fix upstream helps every phone and stays maintained.

Measured, not claimed

A feature counts only when a test run has shown it works; what nobody measured is unknown, never broken.

Why: The picture is honest or it is worth nothing: status is read off the runs (decision 2026-11-17-support-read-off-results).

No manual steps outside tools

What a person does twice becomes a command, a record or a test, so that bringing a phone up can run by itself; where hands or eyes are the measurement, the step is a witnessed test, said before and recorded.

Why: The conveyor's point (the idea, section 03): the same known steps every time, by a person or an agent; manual_work counts what is still by hand and whether it is automated.

Rust, with argenv

linux-phone's tools are Rust, each declaring its command line and environment once with argenv.

Why: One declaration gives the parser, the help, the man page and the completions, so they cannot disagree.

One baseline per device

Every check that ever passed is held to; a check outside a run's scope is not asked, rather than kept in a second baseline.

Why: Two baselines would be two truths about one phone.

The conveyor refuses what cannot work

Each mistake that cost a try becomes a refusal with a reason: a kernel that is not an EFI program, a listening test without the word that the microphone is placed.

Why: A refusal costs a second; a lost try costs a reboot and a wrong theory.

Read the device's own record first

Before cleaning up after an experiment, read what the device itself recorded: a boot entry's try counter, the bootloader's selection, the crash memory.

Why: Three theories about the bootloader were wrong; the entry's counter settled it in one look.

A placed microphone gives relative levels

A microphone placed by the phone tells which speaker is louder from where it stands, and whether there is sound at all - not absolute loudness.

Why: Honest about what the instrument can say.

The phone is the reference

Kept in a known-working state at all times: every experiment is one try that falls back by itself, and the phone is checked well before and after.

Why: A reference that drifts cannot tell a regression from a mistake.

A device lab made from this template holds data only - the manifest, the phone's own checks, its reports, its records; every tool is devlab's and reads the manifest.

The design asked for 2026-11-10 (linux-phone-oco/docs backlog device-template): the next phone must not inherit a copy of surya's scripts to edit; surya-lab already shows where copies drift (its shell tools and devlab doing the same work twice).

Rejected: Copying surya-lab and renaming (the scripts would drift per phone); a template carrying its own scripts beside devlab (two routes to the same work).

2026-11-17

The phone docs begin their own history: their first release is 0.1.0, and versions stay below 1.0 while the docs are still forming. The changelog and manifest inherited from the template they were made from are cleared, with a note saying whose history that was. Release-please reads its config and manifest.

The docs were made from text-as-data-template on 2026-11-04 and carried its history (1.0.0 to 1.2.0) as if their own; never released, release-please found no tag and proposed 1.0.0 - a claim of stability for docs days old and changing hourly. Found after landing: with no release at all, release-please treats the next as the first and gives it its own default, 1.0.0, whatever the manifest says; the config's initial-version (0.1.0) is what decides a first release.

Rejected: Releasing 1.0.0 as proposed (promises what is not there); tagging 1.2.0 (it is the template's version, not the docs'); keeping the inherited changelog (it tells another repository's story as this one's).

2026-11-12

backlog gains device (a devices id) and needs takes phone, research or build. The records that set needs refuse a phone, research or build item without a device (tad has no conditional rule). phone-next and phone-queue require --device; lane-next --device D --needs N gives the lane's next item, for its keeper and launchers. Filled once: open phone items in docs, surya-lab, lab-tools (about deep-sleep) and sxmo-deviceprofiles (about sx-surya) are xiaomi-surya; google-walleye-lab's and lab-tools' about google-walleye are google-walleye. The briefs, AGENTS.md and the README name the device.

Per-lane launchers (ideal-agent decision 2026-11-17-a-lane-starts-its-own) need a lane's next item; needs said only phone, and phone-next could hand surya's items to walleye's keeper. Orchestration (owner of docs), 2026-11-17: the device is a fact of the item, devices.id the reference; required, not optional; list what cannot be placed.

Rejected: An optional --device (a walleye keeper would still take surya's items); the lane read off the project (surya's phone items live in docs, about components); a device on components (components are shared across devices); a needs value per device (needs says what kind, device says whose); a table rule (tad has none conditional yet - the records enforce it).

2026-11-17

A lane coordinator per phone (surya-coordinator) is a visible session in the sidebar: it starts the phone keepers itself, continues or replaces each when it reports, archives finished ones, and routes what needs the author's hands to the top coordinator. The scheduled task linux-phone-keeper-waker only sends it 'continue' when the queue has work and no keeper is live.

The author wants every running piece visible in the sidebar, and a keeper's parent receives its reports automatically; the top coordinator then coordinates coordinators.

Rejected: A hidden scheduled waker that does the keeper's work itself (invisible, no parent to receive reports); the top coordinator starting keepers itself (one session for every lane, its context swamped).

2026-11-17

linux-phone's agents are sessions with a name, a brief kept in docs' prompts/ (bring-up, orchestration, feature-research) and places they own; their shared state is the data they already keep - backlog, decisions, research, session logs, the phone's results - read through ocoeco and drawn on the face, not a tracker of their own. An orchestration session tends the conveyor and the agents: it checks the ways by measuring hand-work, turns every rule it can into a mechanism (devlab's hold, Claude Code command hooks, CI), keeps the face fluent, and starts a research session per hard feature. Research parallelises; changes to the one phone are queued through bring-up.

The author, 2026-11-17, asked for an orchestrating agent, per-feature agents, perhaps an agents-orchestration repository, and the most efficient organisation found by research. Read: the Craft apps' fleet (ownership by subsystem, rules kept once, an oracle gating progress), Gas Town (work state in git, agents as identities), Anthropic (few well-bounded workers, parallel only when independent, ~15x tokens), Claude Code (hooks enforce, sessions and schedules run). Our ecosystem already holds most of it; what was missing was roles, briefs and enforcement.

Rejected: A new agents-orchestration repository now (the agents' runner and its redesign live in creation-guidelines/lab-agent as oco-agent, and how-we-work under creation-guidelines; a third place would be one nature under three names - what is linux-phone's stays in docs, what every project shares goes to oco-agent when it is general); a tracker beside ocoeco such as Beads (two records of one work); an always-on watching agent (tokens without end - patrols on a schedule and hooks do it cheaper); one agent per feature implementing in parallel (one phone: changes race).

2026-11-17

The briefs in prompts/ keep only what is linux-phone's - what a role owns, its places, devlab and the phone, recording in docs - and name the skill for the method from the ideal-agent plugin: orchestrate-agents, research-a-feature, bring-up-a-part, with lab-session-start, land-a-change, record-the-work and change-a-device. The general research and decisions on how agents are organised (landscape photocraft-fleet, gas-town, anthropic-multi-agent, claude-code-agents; decisions 2026-11-17-agents-organised-by-the-data and -experts-written-not-standing) are carried into ideal-agent as its own; the rows here stay as linux-phone's.

The author, 2026-11-17: one home for general agent know-how (grenudi/ideal-agent), each project's docs keeping the domain-specific knowledge, so both improve in their own place.

Rejected: Keeping the whole method in each brief (copies drift between projects); deleting the linux-phone rows that were carried over (they are linux-phone's history and decisions, cited by its own records).

2026-11-17

Calls on surya are made to work as pulpoff/linux-surya carries them - q6voice from sdm845-mainline with SM7150's CVD 2.3 set-up and a hostless VoiceMMode1 link in our kernel, then UCM Voice Call with TX topology 0x10F70 and a 1-channel uplink capture on TX_CODEC_DMA_TX_3 - and proven by the phone itself calling blueSIP's public echo line (+49 89 721010 99701): three tones played on the loudspeaker are heard by the bottom mic going up and again, a round trip later, coming back on the earpiece, found by Goertzel envelopes in a Rust subcommand of devlab-health. Its tone line (99702) proves the downlink alone; the SIM's own mailbox is the fallback. At most one call of 25 s a day; skipped as unknown without a SIM, a registration or the call path. Mobile data is checked every boot over the bearer's own interface (registration, DNS, pings, 100 kB), with a weekly 5 MB throughput run, under 0.3 GB a month. The first step is the kernel: q6voice and the VoiceMMode1 link, settled by the check call-audio-path, which fails today.

An independent mainline tree on this very phone already carries calls with sound both ways, so the biggest unknown is porting, not discovery; the check call-audio-path settles it without a SIM or a call. The echo line is the only public German echo attested across years and sources, and costs a landline-rate call; its tone line splits a failure into downlink and uplink. The acoustic loop proves exactly what a person uses - loudspeaker, mic, uplink, network, downlink, earpiece - and needs no driver feature beyond what calls need anyway (the uplink capture is written to a file instead of discarded). Daily and short keeps the cost to cents and the people reached to none.

Rejected: Digital loop through in-call record/playback ports (unknown whether sdm845-mainline's q6voice has them; kept for later if it does). A second phone on a stand that answers (hardware and a second SIM; the echo line does the same for nothing). A programmable number (Twilio and the like: an account, money, a public endpoint). sipgate's echo 10005 (SIP-internal, not dialable from a mobile, private customers dropped 2025). Old or foreign echo lines (portunity 0211, sip2sip +31, C*NET: unconfirmed, international rates). Calling the author's other phone as the automatic test (reaches a person; stays the half-manual mode of 2026-11-11-telephony-checks). Downstream's 0x10F71 topology (silence without Xiaomi's calibration). A call on every boot (45 a day in bring-up).

2026-11-17

Decision 2026-11-17-one-database is superseded for devices only. Each device (surya, walleye, a third) has its own open base, made from device-template and following idealkb: queue, tries, measurements, decisions, research about it, its parts with status, evidence and date. docs holds concepts, the components and features catalogue, landscape, general decisions and research, shared sources, the tests catalogue, the lab tooling, and a registry of devices with the address of each base; support status and progress are derived from the devices' declared parts, pulled in CI, never typed or copied (stale or missing: not known yet). Lanes and launchers ask their device's own base. A third device is made from the template and registered with one record. The work to get there is on docs' backlog under commons-only, each part with its owner.

40 of docs' own 81 backlog items, 34 of 49 research rows and 14 of 28 decisions name a device; test_results is 1.3 MB of 2.0 MB; the keeper's landings conflict in docs' data; the author wants docs to hold only what helps all devices. The device field and lane-next (docs 260) separate lanes but not weight or conflicts.

Rejected: One database with a device field (lanes only); status typed in docs and in the device; submodules or subtrees; push from each device; CI-only derivation (a phone cannot run in CI); superseding one-database wholesale - its reasons still hold for docs and the lab tools. Full reasons: grenudi/ideal-knowledge-base decision 2026-11-17-commons-and-unit-bases.

2026-11-17

docs is ideal-knowledge-base's first follower: idealkb.toml pins release 0.1.0, the generic queries next, find, row and recent are idealkb's, and AGENTS.md is the short entry - two lines on what docs is, linux-phone's own questions (phone-queue, phone-stands, coverage, a place's records, the agent folder), and idealkb's generic part between idealkb:begin and idealkb:end. docs keeps as its own: its about query (it also reads the support matrix, feature support and the tests), its records (they take --project: one database of several places) and tables.toml (its standing tables carry project, needs and proof). The editing recipes moved to CONTRIBUTING.md whole.

Decision 2026-11-17-ideal-knowledge-base, accepted by the author; backlog kb-entry and idealkb-from-template. A base's extensions named as own are not overwritten by the weekly pin job, which says when idealkb changes one of them.

Rejected: Taking idealkb's records and about query (they would drop --project and the support matrix: docs' own CI and devlab's filing stand on them); renaming docs' queries to fit (every link and brief naming tad q about would break); deleting the recipes from AGENTS.md (they are still how the data is edited - they belong in CONTRIBUTING.md, which a person reads to change it); moving the base into a subfolder (devlab's filing, Pages and the mark stand on the root - the decision's own rejection).

2026-11-17

Removed queries/lane-next.sql, phone-next.sql, phone-queue.sql and the phone-queue view of face/lens.toml; the briefs (README, orchestration) and tables.toml's comments point at each lab's own base. docs' needs and device fields stay as words of the item (what it would need, for which phone), routing nothing. The lpoco roof items whose waits named another item (bringup-image-swap, bringup-pin-and-hooks, bringup-release, device-template-names-bringup, lpoco-rename-lab-tone, lpoco-mcp-one-door) now carry blocked_by and an empty waits (idealkb 0.12 rule). Open docs items with needs phone (health-suspend-cycle and older ones) are queued for their lanes by backlog docs-phone-items-to-lanes.

ikb-cli (2026-11-17, via the top coordinator): since surya-lab #136 and google-walleye-lab #15 both launchers, the keepers and the waker read their own base; nothing in idealkb depends on docs' copies, and they test waits IS NULL only, so they ignore blocked_by. Two routes to one queue are one nature under two names (practice 32): one route stays, the device base's.

Rejected: Keeping them for a general queue: docs' general queue is tad q next, which already shows blocked_on; a second docs-only lane queue would drift from the device bases' form. Updating them to blocked_by: work for a route nobody reads.

2026-11-17

An expert is a domain written down in docs, not a session kept alive. Each hard domain (audio, sleep, modem, sensors, cameras) is its component's rows - research, decisions, backlog, tests, sources - plus one research row per domain, DOMAIN-how-it-stands, that holds the tacit part (dead ends, where experiments live, what to never do again), added to item by item, never rewritten whole. A session takes up a domain by its brief and that domain's rows, and becomes its expert by reading them. It is ended when its part lands, or before its context is compacted, after writing its hand-over into those rows (not into notes outside the repository); the next starts fresh from them. Questions route by the record first: whoever asks reads the domain's rows; if they do not answer, they message the domain's live session directly (the face shows where each hand stands), not through orchestration; with no live session, orchestration starts a short read-only consult from the domain's rows on a lighter model, and every answer is written back as a row. One writer per domain and one hand on the phone (devlab) stay as they are.

Measured here: sessions grow to 1000-1800 messages and re-read them every turn; multi-agent work costs about 15 times one agent; a phone serialises all bring-up. Outside: compaction loses what only later proves to matter and summaries collapse; long contexts recall worse; relayed questions play telephone; every system that keeps experts across time (Gas Town, Anthropic's harness, Claude Code's agent memory, Letta) keeps the expertise outside the session. The author's aim - knowledge that does not depend on anyone remembering - is practice 1 of the ways.

Rejected: Standing expert sessions per domain: idle hours lose the cache, so each question re-reads a thousand-message context at full price; the expertise still vanishes at compaction or when the app's session ends; their context rots with length. Orchestration as the router of every question: a bottleneck and a game of telephone (LangChain), and it fills orchestration's own context. Claude Code subagent memory (.claude/agent-memory) or agent teams as the home: a second store beside docs' one database (decision 2026-11-17-one-database), and teams do not survive a resume. A Markdown expert-notes file per domain: a second place for what rows already hold; kept only if a lens cannot show it. A vector or memory service (Letta, Hindsight): outside the commons and opaque to the face. Forking a finished expert's whole session to consult it (Cognition's smart friend): kept as an exception for a session a few hours old whose tacit context is not yet written, not the rule.

2026-11-17

No more agents for now; the conveyor session retires and hands everything to orchestration, which becomes the one session the author talks to; bring-up runs as one session per part, ended when the part lands and the next started fresh from the data; research sessions run one or two at a time, the next (sensors) only after deep-sleep shows the research brief works; the most capable model where judgment is the point (bring-up, research decisions), lighter ones for patrols and routine conveyor fixes.

Measured over ~80 minutes on 2026-11-17: the conveyor files results by itself (devlab 12 landings); the phone queues every change, so only research parallelises; 4 sessions on the most capable model already run, and multi-agent work costs about 15 times the tokens of one (Anthropic); a session that runs long re-reads its whole context every turn - the conveyor session's was the longest; collisions came from many hands landing in docs at once (2 of 5 gatherings failed, healed by the next boot). The author asked for the most effective organisation, not the largest.

Rejected: More agents per feature now (one phone queues their changes; the research brief is unproven); keeping the conveyor session beside orchestration (two owners of one thing, the costliest context); one long-lived bring-up session (its context grows with every part).

2026-11-17

Hardware a phone's work needs beyond the phone - cables, adapters, breakouts, meters, and the setups made of them - is one table, hardware, in one shape: in docs as the general catalogue (status general: what a thing is, its spec, wiring and sources, written once for every phone) and in each device base (what that lab wants, has or lacks, and whether it is CONFIRMED on that phone). Fields: id, kind (cable, adapter, breakout, meter, tool, part, setup), name (with the chip or conductors that tell variants apart), status (general, wanted, ordered, owned, lent, broken, retired), fit (claimed, confirmed, refuted - on that phone; confirmed needs fit_ref, the evidence), spec, wiring, serves, about, general (docs:ID of the catalogue entry), qty, price with price_on (a price needs its day), sources, file, note, checked_on (required). A backlog item names the hardware it cannot be done without (hardware, ids): phone-next and phone-queue read it off the data - it waits until each is owned and none refuted (phone-queue shows awaits_hardware), the same way blocked_by clears itself. Stock is kept in the base of the lab that holds the thing; the catalogue holds no stock. Records: hardware, hardware-status (it arrived, it was tried), query: tad q hardware (status, kind, about; days since checked). device-template carries the structure (surya-lab and google-walleye-lab have it); the first rows are the Pixel 2's UART cable: four sources, the 1.8 V adapter, the SBU breakout, USB-Cereal and the setup, all claimed and none confirmed.

Read: how Snipe-IT (model vs asset, typed status labels, purchase cost with purchase date), Part-DB (lots by location, supplier price details, a needs-review flag), KiCad (custom fields, no status or price date) and OpenBOM (item vs usage) keep parts, and what the sources of the Pixel UART cable say (bacon.dev, Peter-Easton, xairy, google/usb-cereal): prose and SKUs, claims told from tests only by reading, prices undated, a repository archived. Failure modes seen there - stale prices, claimed read as confirmed, the same name for different chips (FT232R vs CP2102N; a stock cable without the SBU lines), settings lost (1.8 or 3.3 V, orientation) - are what the fit/fit_ref and price/price_on rules and the spec line answer. The lanes read only their own base (decision 2026-11-17-commons-and-device-bases), so the question 'is it owned?' has to be answered there.

Rejected: Stock only in the docs catalogue, with device rows deriving it (the research's recommendation): a lane would have to read docs for 'owned?', which the device-base decision ended; a shared adapter listed in two bases is the cost, noted in `general`. A separate lab-inventory base: a third place for two labs; revisit if more than a few things are shared. A hardware section inside parts: parts say what the phone's components do, not what the bench needs. A new idealkb generic table: hardware is linux-phone's, one domain uses it; extract when a second does. Free-text notes on backlog items for 'needs the UART cable': nothing reads them, so a try would start without it. Quoting a retailer's claim as a fact: fit defaults to claimed, and confirmed needs evidence.

2026-11-17

Where it stands (2026-11-17): accepted. The author accepted the corrected design the same day ('looks clean, i like it', said of this decision as it stood after docs #174, relayed by the conveyor session). Landed: the about link and the about query (docs #170) and the agent folder (docs #171). Open as work, waiting on no one: building idealkb (idealkb-from-template, its own session) and the short entry (kb-entry). The decision, as corrected by the author: tad stays what it is - a database, transparent, workable in SQL, at ease in git and displayable - and how to organise a knowledge base is written once, in a new repository, grenudi/ideal-knowledge-base (idealkb), which uses tad as its database by pinning tad's release and grows on top of it what a knowledge base needs. (1) The rule of file and table: a thing there are many of with one shape, that is cited, linked, dated or changes state, is a row (decision, research, source, backlog, session log, concept, test, status, word); prose read once in order is a file (README, AGENTS.md, a brief, an essay too long for a row, kept in research/ and cited by a row); rendered pages are output for people and the face, never what an agent reads to answer; the named statements are the base's interface. (2) The about link: every record table names what it is about in one field, checked by a references rule against the base's subjects - Wikidata's statement about an item. (3) The generic statements every base gets: queries about SUBJECT, next, find TEXT (ids and first lines only), row ID and recent; records with --about. (4) One entry: AGENTS.md under 3 KB, with CLAUDE.md as @AGENTS.md - what the base is in two lines, an orientation table from typical question to the command that answers it, tad statements for everything else, and the rule: never read data/ or docs/ to answer, ask a query. (5) The standing record tables: backlog, session_log, decisions, research (with sources). (6) Its own tad base describing itself. A base follows idealkb by a pinned release, as it pins tad: the weekly pin job keeps the generic declaration, statements and entry current, landing only where the base's CI passes; a base's own change to a generic file shows as a diff in that job's pull request, the signal to send it upstream. Starting a bare tad database belongs to tad itself - for example a tad init in place of the template's scaffold - general to any database, with nothing of a domain. text-as-data-template hands its pieces to those two (the scaffold to tad, the standing tables to idealkb), its reasons are carried into their records before it goes (Chesterton's fence: what each piece was for, from its session_log), and it is retired with a pointer. How an agent finds its way in any base is a skill of ideal-agent; ideal-project-playbook keeps the process and points to idealkb for its backlog, development-log and idea templates, and its findability test becomes idealkb's measure. In linux-phone-oco/docs the root stays the base, and the agent specifics are in ideal-agent-linux-phone-oco/ (done). For later only: tad's README keeps rendering in tad until it moves to a tool of its own; by this split it belongs eventually with the knowledge base and the face.

The author, 2026-11-17: one general place for how to organise a knowledge base, used by every base; agents find what they need instead of reading everything; don't reinvent the wheel, don't make it more cumbersome. Corrected by him the same day: tad stays a database, and idealkb uses it as its database and grows a knowledge base on top. This agrees with tad's own record - its whole concern is the data, and what is done with the data belongs to the tools that use it (2026-11-12-tad-is-text-as-data). The template is tad's starter from the vendored era (a Python .tad/ copied in by git subrepo, plus standing backlog and session_log tables); renamed into idealkb, it would have folded a database's scaffold into a knowledge base. Measured (kb-navigation-measured): the weight was a missing subject link, not the size of the entry. The world's practice agrees (kb-organisation-world); the commons' overlaps are in kb-organisation-commons.

Rejected: Growing idealkb by renaming text-as-data-template (this decision's first form): it would fold a database's scaffold into a knowledge base; the author corrected it. The first form's rejection of 'a new idealkb beside the template' no longer applies: once the template is split between tad and idealkb, nothing remains beside it. Putting the knowledge-base layer into tad: tad's concern is the data alone (2026-11-12-tad-is-text-as-data). Folding it into ideal-project-playbook: the playbook is how to run a software project, and a base is not one. Folding it into ideal-agent: a base is read by people and the face too; ideal-agent keeps only the navigation skill. Moving docs' database into a subfolder named ideal-knowledge-base-linux-phone-oco: devlab's filing, tad's working directory, GitHub Pages' docs/, the mark's exports and every link to a row's page stand on the root. A copied template: copies drift, as this one has. A spec document alone: nothing checks that a base follows it. A plugin skill as the vehicle: only Claude agents would get it. llms.txt as the agent's entry: it serves outside readers of a site. Embeddings or a vector index: 4k rows are answered exactly by a checked link and named queries. A table of questions naming their queries: a second index to keep true. A folder per Diataxis kind or PARA bucket: the tables already sort by kind.

2026-11-17

A lane's rows move from docs into its lab's base, replayed through the base's named records under the lane's keeper lease (orchestration-move): backlog whose device is the lane's (except lab-tools' own items, the conveyor's) or whose project is the lab with no device; research, decisions and log of the lab's project or about a moved item; their research/ folders; test_runs/test_results replayed from the lab's own reports through test-run and compared row for row; parts seeded from docs' support_status of the device. Kept as they were, except: an about naming the device, a docs subject or a milestone is left empty; decision ids without a date gain it; a research without a brief takes its question. The moved rows are deleted from docs through tad sql. Scripts: side-session notes of orchestration (move-lane.sh, replay.sh, select.sh).

The device base must hold the lane's whole story to be its own (decision 2026-11-17-commons-and-device-bases); replaying through the records keeps every rule of the new base; an about across bases has no rule yet (about-across-bases), so leaving it empty loses only a link the base implies.

Rejected: Copying data/*.json lines by hand (bypasses the records and the base's rules); moving lab-tools' items that carry a device (they help every device); keeping support_status' surya claims only in docs (the base would have nothing to be about); renaming ids freely (links from elsewhere would break).

2026-11-17

For linux-phone-oco, everything goes through tad in one database: linux-phone-oco/docs. The records its places kept in ocoeco's oco/ tables (lab-tools, surya-lab, device-template, sxmo-deviceprofiles) are docs' tables now, each row naming its place in project (full id, linux-phone-oco/NAME); docs' mark holds those places, so on the face each record stays its place's. Every record is written through tad's named records kept in docs (records/NAME.sql: tad r decision|backlog|backlog-status|research|session-log|concept|source|milestone-readiness --project NAME ...), read through named queries (queries/), and the feeds, the status derivation and devlab's filing of a run are named records too. The record of work is git itself: linux-phone places export no glimpses, land asks for none, landit makes none, devlab's landings carry none; commits are signed by the name a session works under (oco-work sets the git author to OCOECO_BY), and the face reads where each hand stands off the commits (bin/landings.sh, landings) after the glimpse history kept in docs. Sub-repositories' marks shrink to the mark itself, pointing here. The face keeps its CI (observe through linux-phone-oco/lens, drawn by the engine); drawing it straight from this database waits until observing becomes a burden. ocoeco stays as it is for the rest of the commons.

The author, 2026-11-17: for linux-phone everything goes through tad in one database, and the record of work is git itself. Measured friction behind it: the turn commit-title limit failed 4 times; refusals of links pointing nowhere ordered the work 3 times; and two tools (ocoeco note and tad) wrote rows in one place - docs' decisions, problems and glimpses were ocoeco's files beside tad's tables, undeclared, and appended glimpse lines conflicted between sessions landing at once (seen again on 2026-11-17 in lab-tools). Checked before the old way was retired: every row of every place is in docs (lab-tools 110 with glimpses, surya-lab 99, device-template 12, sxmo-deviceprofiles 10, lens 3), the 25 tables the face reads observe the same, and the face rendered from both is the same page for page but for each mark's count of shared tables.

Rejected: Keeping ocoeco note beside tad (two tools writing one database - the overlap this ends); one database per sub-repository (one nature kept in five places); retiring ocoeco everywhere (the author's observatory rests on it, and it was not asked); a new 'ocotad' command line over the database (a second tool over one database: tad's named statements say the same as files beside the data); queries compiled into tad (each new one would need a release of tad, where a file lands with the work that needs it); drawing the face from this database now (its CI works; not before observing is a burden).

2026-11-17

records/feed-device-parts.sql (run per device with a base, devices.base = owner/name, by bin/run-feeds.sh) writes the device's support_status from its base's data/parts.json, only when devicebase.toml says parts = 1 (read as the one line 'parts = N' by a regular expression over the file's text in DuckDB, which reads no TOML; checked against walleye's and surya's real files). A part is kept when its status is one of the five and its updated is at most 30 days old. Otherwise the component is unknown, with a note 'Not known yet: ...' saying why: contract not declared, part not claimed, row not valid, or last said X on DATE more than 30 days ago. A component docs knows that the base does not claim is unknown. A base that cannot be read (404, not JSON) makes every component of that device unknown through records/device-parts-unknown.sql, and never stops the other feeds. derive-support-status leaves devices with a base alone. feeds.yml runs daily plus workflow_dispatch; no push trigger (a repository_dispatch from each base needs a token in each lab).

A status nobody has re-measured for a month is not known any more; an old 'works' on a moving kernel misleads. 30 days is as long as a phone's mainline state stays trustworthy between lab sessions here, and short enough that a lab left idle shows it. Practice 12: not measured shows as not known yet.

Rejected: No staleness window (an abandoned base would show works forever); 7 days (a weekend-less lab would flicker to unknown); unreadable base keeps the last pulled rows (hides that the base is down); unreadable base shown as broken; a TOML parser or Python for parts = N; on: push of the bases (needs cross-repo tokens).

2026-11-17

linux-phone-oco's founding principles are five concepts of docs with an ord (tad q principles; the page is concepts.md, each an anchor): as-good-as-android, measured-not-claimed, mainline-first, no-manual-steps, rust-with-argenv. Each has a one-line statement, a why, and - where it rests on a general practice - rests_on cites ideal-agent's practice by number, never its words. Briefs, guides and the device repositories' AGENTS.md cite a principle by a link to its anchor and never restate it; bin/check-principles.sh (in make verify) fails on a cited id that is no concept and on a principle the briefs' README does not cite. A decision or a piece of work that rests on one names it in --about (concepts are now valid subjects), so tad q about --subject no-manual-steps lists them and tad q principles counts them. An id keeps its meaning: a principle that changes in meaning gets a new id, the old row stays as it was. The face already shows concepts under its ideas view; a view for the principles alone is for the face's owner. The tool side of no-manual-steps (manual_work, the lab preparation) stays with orchestration. Proposed to ideal-agent's owner: overlay-check takes the principles' text as an extra base, so a brief that restates one is flagged like one that restates a practice (measured: nothing restates them now).

The principles were scattered: the story in the idea table, practice-12-style lines repeated in briefs (phone-keeper) and device AGENTS.md, nothing numbered or citable, and the author asked for them to be noted once and referenced. Every durable charter read (Debian's Social Contract and DFSG, the Mozilla Manifesto, Wikipedia's five pillars, Rust's API guidelines checklist) is small (5 to 10), on one page, with short stable ids that are link targets; none enforces refer-not-restate mechanically, so here the link is checked and the restating is measured (overlay-check). Concepts already render with anchors and the face already shows them, so a new table or page would duplicate.

Rejected: A separate manifesto file (MANIFESTO.md): prose nobody can cite by id, with no check and no place on the face. A new principles table: another page and a second kind of concept beside the five conveyor concepts, not shown on the face. Putting the principles into ideal-agent: they are linux-phone's; ideal-agent keeps the general practices, and the principles cite them. Numbering by 1..5 only: a number changes meaning when one is inserted (Wikipedia and Rust keep stable names). Restating a principle's words in each brief for convenience: the drift the author asked to avoid. Versioned texts as in Debian's 1.2 or the kernel's DCO 1.1: ceremony for five rows; a changed meaning gets a new id instead.

2026-11-17

docs follows idealkb 0.3.0: a subject's answer leads with its summary (tad r summary), condensed records by id; tad q about says where a summary is due. docs' own about query, research record and tables.toml take summaries, material and supersedes the way idealkb's do, keeping docs' status, feature, concept and test rows always in full. Research material lives in research/SUBJECT/YYYY-MM-DD/, named by its row; the Open Handset Commons model is the first, moved under its date. The session that records into a subject renews its summary when due; a keeper at hand-over.

The author, 2026-11-17: a subject's answer must not grow without bound, and research must be kept without loading every agent's start (idealkb decisions 2026-11-17-summary-layer and 2026-11-17-research-aside). Measured: audio-mic from 15.9 KB to 4.8 KB.

Rejected: Summarising the domains' how-it-stands research rows in place: they are itemised hand-overs (decision 2026-11-17-experts-written-not-standing), records the summary condenses, not the summary itself. Condensing status, tests and concepts too: they are short, standing facts a reader needs every time. Writing all four due summaries now: each belongs to the session that knows its domain; this change proves the layer on one.

2026-11-17

A part's status is derived (derive/support-status.sql, run through tad after every filing): broken where the latest run fails it; works where a test that proves the part does its work passed and none failed; otherwise what a person judged (judged, with the notes as its evidence). Each row says what the suite saw of the part and in which run (measured, measured_run); the tests table says what each test's pass proves - present or works.

The author, 2026-11-17: support status read off the suite's results, not typed. Tried beside the hand-written status first: read naively (a pass is works, nothing measured is unknown) it disagreed on 8 of 19 parts - a pass that only shows a part is there (the jack detector, Bluetooth powered, the modem seen, the NFC controller) is not the part working, and an absent measurement is no evidence against what was witnessed (the microphone's tries, fastboot). With proofs told apart, the rule and the judgment say the same on all 19.

Rejected: Status typed by hand alone (it lags the phone: nothing turned it broken when a part failed); a pass read as works (would have called calls, SMS and NFC working with no SIM and no tag ever read); a measurement-less part read as unknown (would erase what was witnessed).

2026-11-17

linux-phone's face is drawn from docs' own data: bin/face-data makes the engine's data from docs' tables (each row naming its place), the lens kept in docs' face/ (lens.toml, its translations and log, moved from linux-phone-oco/lens), each place's mark (oco.toml) and what GitHub says the work made (commits of 90 days, each workflow's latest run, releases); the engine (oco site) draws it as before. ocoeco observe and the lens checkout left pages.yml (docs #182), and no brief has an ocoeco step: the whole is read through docs' named queries and the face.

The author, 2026-11-17: linux-phone must not depend on ocoeco. Since docs holds every linux-phone record in one tad database, observing the family through ocoeco only re-gathered what docs already keeps. Checked before landing: drawn from both, the same 120 pages; outside the build time only 16 differ, and only where the new data is fuller - activity counts every place's commits (393 in 90 days, not docs' 186), releases show (observe found none), every workflow's latest run shows. Proven on the live face after landing.

Rejected: Keeping ocoeco observe (another project's tool to read our own data); the face drawn by tad render alone (it renders tables, not the face's views - matrices, paths, the queue; the engine does those); a Rust step for the data now (jq, yq and gh do it in a page of shell, as the CI step it is - a Rust step when it grows logic); keeping the lens in its own repository (a second place for the face's one definition); renaming OCOECO_BY (only a variable's name; oco-work and land read it across the ecosystem).

2026-11-17

linux-phone's pages (linux-phone-oco.github.io/docs) are its face, drawn in this place's CI from its open database: tad keeps and checks the data here; the family's other places are observed as the Linux Phones lens gathers them; the observatory's engine draws the face from that; tad's page of every table stands beside it under tables/. A landing here draws it again, and the clock every three hours, for what the other places land.

The author, 2026-11-17: the observatory's Linux Phones pages reflected real progress from CI and should be linux-phone's own face, with tad as the open database shared by the whole project, devlab filing the suite's results into it and the pages reflecting them - nobody drawing them by hand.

Rejected: A copy of the observatory's pages kept here (a second renderer to drift); publishing from the lens's place (the database and its readers would live apart, and docs' address is the one already linked); the plain table index alone (it drew rows, not progress).

2026-11-17

surya has one keeper: the one session that owns the phone's flow, taking up the phone's queue one change at a time; devlab still holds the phone for each change. The keeper is a role filled by successive fresh sessions: each takes a lease (devlab keeper take), reads how the phone stands (tad q phone-stands, the last keeper's hand-over) and the queue (tad q phone-queue: backlog items marked needs=phone, each with the test that proves it; also on the face), works to proofs, writes how the phone stands and ends when its piece lands or its context grows large. Research, expert and conveyor sessions never change the phone; they put work on its queue. A waker (a scheduled task on the lab) becomes the keeper when the queue has work and the lease is free. The brief is docs ideal-agent-linux-phone-oco/phone-keeper.md, the domain part of ideal-agent's keeper of a shared resource. Bring-up's role becomes the phone keeper's.

The author, 2026-11-17 ('yes, hand it over'): one owner of the phone, always taking the next thing it needs, filled by successive sessions. The bring-up session had grown to about 1,770 messages: a session held as the phone's long memory is slow and costly, while the phone's state and work are already data. devlab's hold makes each change safe but says nothing of what comes next; a queue read off the backlog does, and research sessions had no way to hand the phone work but a message.

Rejected: Bring-up as one long-lived session (its context grows without end, and the phone's knowledge lives in a conversation); several sessions changing the phone in turn without an owner (devlab serialises changes, not intentions - experiments interleave); a separate queue table (one nature in two places - the backlog already holds the work; needs and proof are two fields on it); a lock of our own around devlab (it would wait on itself; the lease says who keeps the phone, not who holds it for a change); a waker that starts a second session beside a live keeper (the lease refuses the second).

2026-11-17

The core of the project - making each part of a phone work - runs as its own session beside the conveyor's, from prompts/bring-up.md: it owns the kernel, the phone's hardware data, the upstream queue and the Sxmo profiles; the conveyor's session owns lab-tools, device-template and the face. Anything that changes the phone's state is done holding one lock (flock on ~/.local/state/devlab/CODENAME/phone.lock); each session works in clones of its own.

The author, 2026-11-17, asked for a parallel session on the actual core: research, reverse engineering, patches, delivered through the conveyor and proven by the suite. One phone and shared clones are where two sessions would undo each other (two jobs in one clone once merged each other's changes under one commit).

Rejected: One session doing both (the conveyor kept pulling attention from the parts, and parts from the conveyor); two sessions without a lock or owners (a reboot under a kernel try, a reset clone).

2026-11-17

The first kernel is pristine kernel.org v7.3 with arm64 defconfig plus gadget/configfs options, and a new msm8998-google-walleye.dts (GPL, derived from the wahoo dtsi of kcxt/porthole with licence and authors kept) that enables only reserved memory, RPM regulators, qusb2phy, dwc3 peripheral (USB 2.0), ramoops and UART, and carries qcom,msm-id = <0x124 0x20001> and no bootargs. It is booted once with fastboot boot, in a boot image of header v0 with the dtb appended. Further parts are added one at a time, taking porthole's patches singly.

Mainline has no Google board; the only maintained Pixel 2 family kernel (porthole) is shaped by taimen and its walleye board is untested, so a walleye failure on it would not say which of 263 patches or which board difference caused it; a minimal dts keeps the first try small and attributable (bring-up-a-part: test first, one part at a time). v7.3 is the newest release; v7.2.2 is what porthole proved on taimen.

Rejected: porthole's whole 7.2.2 series as the first kernel (too large to attribute a failure); kcxt wahoo/5.17 (old, bootargs in the dts hides the bootloader cmdline, no msm-id); display-first or simple-framebuffer start (command-mode panel has no scanned-out framebuffer); flashing dtbo/boot first (decision walleye-fastboot-first); adopting a downstream 4.4 kernel (not the aim).

2026-11-17

1) A control: a public stock-format walleye image (LineageOS recovery or TWRP) through the same fastboot boot, to learn whether the phone's state or our image causes Load Error. 2) Host-only rebuild of the image on the pmaports blueline recipe (second offset 0, os word 0, short cmdline) and a dts with qcom,board-id/pmic-id read from the stock walleye dtb, tried one change at a time. 3) Only if both still end in Load Error, a stub dtbo in dtbo_b - a write with a recorded way back, needing the author's word.

Nothing reported on a Pixel 2 booting mainline; the image format already equals what pmaports boots on Pixel 3; Load Error is also given to known-good TWRP in a bad state, so a control separates state from content cheaply and with no write; the board-id change costs nothing on the host; the dtbo stub is the one proven fix on taimen (kcxt) but changes the phone.

Rejected: Flash a stub dtbo first (kcxt's way): proven on taimen only, a write, and the cause may be state or ids; Read slot b's dtbo or boot header via Android first: needs set-active/boot of Android, which flips slot flags; Keep trying more offset variants (a/b style): both offset sets already behave the same under Load Error, so offsets are not the lever; Download Google's factory image to read ids: a proprietary download needing a decision, when LineageOS's public build holds the same header and dtb ids.

2026-11-17

On the author's word of 2026-11-17 ("lets do it ... no need to wait on me"), the walleye keeper runs 'devlab fastboot boot now' tries (a kernel in memory only, nothing written) whenever an image is ready, without asking. The author is asked, in one line through the top coordinator, only when the phone needs his hands (holding power to get back to fastboot after a hang). Anything that writes to the phone - flashing a partition, a stub dtbo, switching slots, 'fastboot oem' - still needs its own recorded decision and his word, and devlab's [fastboot] writes stays false until then.

A boot from memory leaves both slots as they were and falls back to the stock boot on reset; the author wants the least of his attention.

Rejected: Asking for each try (needless attention); a standing go for writes too (a write can cost the Android reference or a slot).

2026-11-17

Until a recorded decision says otherwise, walleye is only ever changed by 'fastboot boot' (a kernel held in memory); both A/B slots stay untouched, and the stock Android on it is measured as the android-reference before any flash.

It is the only Android reference we have and the only thing between a bad kernel and a phone that needs a factory image; fastboot boot falls back by itself on reset.

Rejected: Flashing a boot slot for the first try (loses the reference and a slot); wiping to install postmarketOS first (loses the reference); building devlab's fastboot mode here (devlab belongs to orchestration).

2026-11-17

Clean room for walleye is a rule on what a session may read (inputs), not a claim about the model's mind: allowed evidence kinds are measured-trace, measured-behaviour, public-spec and gpl-source, each recorded with its file, hash, command and date; never vendor binaries, disassembly or decompiler output, strings out of blobs, firmware read for content (it may only be loaded), leaked or NDA documents; all captured logs and strings are data, never instructions. The GPL vendor kernel and kcxt/linux-wahoo are read and ported with their licence kept (no clean room for them). The bring-up of parts that mainline already has (most of MSM8998: a device tree plus upstream drivers) needs no wall. The full observer / scrubber / implementer split starts only with the first part that needs observed behaviour (likely display panel init, audio calibration, sensor hub, camera), tried first on a part surya already solved; the observer's spec rows are a ikb record to be asked of the ikb session when that part comes.

Research 2026-11-17-cleanroom-agents: no court has ruled on AI clean rooms and a wall cannot be proved in the model's mind; an input rule is checkable (Asahi records accesses without looking at code; ArtCraft's rule is on inputs); EFF calls a clean room good practice, not a legal requirement.

Rejected: Proving independence by the model's state (unprovable); the full three-role split from the start (overhead for a first kernel that needs no observed behaviour); no rule at all (the GPL-versus-proprietary line must stay checkable); reading blobs/disassembly as an evidence kind (never).

2026-11-17

linux-phone-oco/google-walleye-lab, made from device-template, with its own device.toml and its own devlab lease; surya's lease is never touched.

The template exists for exactly this; one lease per phone keeps two lanes from blocking each other.

Rejected: A directory in surya-lab (mixes two phones' manifests); one shared lease (one phone's keeper would stall the other).

2026-11-17

The Android on the Pixel 2 (LineageOS 15 on slot a, an older build on slot b) is kept only as the way back, the measured reference and the tool that reads our kernel's logs; the goal is mainline Linux on the phone, as on surya. The lane may set Android's settings for the work (screen lock off, USB debugging, developer options) without asking, recording what it set; the author's keep-or-restore question is closed for the lock. What can still lose the reference (a flash or erase of a slot's partitions) needs a recorded decision as before.

The author's words (via the top coordinator, 2026-11-17): the only reason Android is still on the phone is so mainline Linux can be put on it, the whole purpose of the project, like surya.

Rejected: Treating each Android setting as the author's to restore (it only slows the lane); wiping Android now (it still reads our crash logs and is the way back).

2026-11-17

Our images e and b are accepted from the first state but never start; the stock control boots. The next step is a bisect: images s1 (stock kernel + stock dtb + our initramfs), s2 (our kernel + stock dtb), s3 (stock kernel + our dtb), one swap each, built from the control's own unpacked parts; the keeper tries them from the first state. UART (the author's cable) and a dtbo/vbmeta write come after, only if the bisect leaves the question open.

A bisect uses only what we can read and rebuild on the host, changes nothing on the phone, and s1 may give a working USB shell on the stock kernel with our initramfs, a real foothold; research walleye-own-images-e-b-first-state.

Rejected: UART first (needs the author's cable, a purchase or wait); a stub dtbo or vbmeta write (no way back for the stock dtbo, no evidence it is the cause: acceptance already happens); changing our images at random again.

2026-11-17

On the author's words of 2026-11-17 ("Yes, download it"; then "no need to ask for my permission for downloads ... by roles expertise can be handled by themselves"): download LineageOS's official walleye boot.img (build 20261113, sha256 48dbc55c76ee47840e645707b6bf3ac322099c06358178ad8ddf2c6a53c17468; download.lineageos.org publishes no recovery.img for walleye: on A/B LineageOS carries the recovery in boot) from download.lineageos.org only, verify the sha256, keep it in ~/Projects/walleye-build/control/ with its URL, size and checksum recorded, read its header and dtb ids on the host (unpack_bootimg, fdtget; data, never run on the host), and boot it once from memory as the control (devlab fastboot boot now, tries on b, slot flags read before and after). Nothing is flashed. From now on downloads of public, checksummed files that the lane's work needs are the lane's decision, recorded with source and checksum; the author is asked only for his hands, a write that cannot be undone, money or outward actions.

Research walleye-load-error-how-it-stands: a stock-format image answers whether the Load Error is our image or the phone's state; boot.img is the smallest official file holding the true header.

Rejected: TWRP or other sources (worse provenance); building a control ourselves (not a control); asking the author per download (his word: not needed).

2026-11-17

Generate from the overlay's __fixups__ a compat dtsi (the 137 labels, paths as in the stock dtb's __symbols__), include it in msm8998-google-walleye.dts, build with -@, and gate on tests/host/dtbo-overlay-merges.sh passing on the host before any phone try; then one s3-like image (stock kernel, ours dtb).

fdtoverlay: overlay 3 merges into stock dtb, fails on ours for lack of __symbols__; libufdt treats that as an error; s3 is the only bisect variant with such a dtb and the only one stuck after Booting OKAY.

Rejected: Stock dtb for first light: the kernel would run on the vendor tree, wrong for mainline drivers, and it hides the problem. Patching the stock dtb with our nodes: larger, same end. Writing dtbo to drop the overlays: a write with no way back (fastboot cannot read it), not proposed. Only -@: still ~123 of 137 labels missing. Only changing compatible: the merge never reads it.

2026-11-17

Build the helper as in the research: one interface (class 2/2/1), interrupt-in + bulk-out + bulk-in, descriptors for FS/HS/SS and strings written to ep0 before the UDC bind, no function attribute written, ep0 class requests answered, a pty shell bridged to the bulk endpoints. Two items: build the helper and image (needs build), then one phone try proven by tests/host/ffs-acm-up.sh (fails today, written with this decision).

f_fs rejects CDC functional descriptors in 4.4.302 and 7.3 (read in source); cdc_acm's probe accepts a single combined interface of three endpoints (read in source); this needs no kernel option the vendor kernel lacks. Not yet run on the phone.

Rejected: Full CDC-ACM descriptor set (header/call-mgmt/ACM/union) over FunctionFS: ep0 write fails -EINVAL. configfs acm/serial/ecm/rndis functions: not in the vendor kernel. Android adbd as the channel: bionic userland, already rejected. A libusb-style custom vendor-class interface: needs a host program instead of the stock cdc_acm driver. Writing function attributes: the 5b panic path.

2026-11-17

The FunctionFS ACM console on the vendor 4.4.302 kernel is parked, not pursued. Two findings contradict each other and close the route: the research (walleye-ffs-acm-helper-how-it-stands) found that f_fs rejects CDC class-specific (0x24) descriptors in this kernel, and the keeper's try of n3r (walleye-cdc-acm-needs-functional-descriptors) found that the host's cdc_acm refuses the interface without them ('Zero length descriptor references', -22). So cdc_acm cannot bind a FunctionFS gadget here. The vendor-kernel facts we need come one-way through the mass_storage log window (m1, proven by lpoco-host's acceptance test). The interactive console is for OUR mainline kernel, where configfs ACM (CONFIG_USB_CONFIGFS_ACM) is native and gives /dev/ttyACM0 without FunctionFS. The C probe's removal (walleye-code-hygiene-rust-ci) is unblocked; the Rust helper stays in the tree as a built, tested artifact until the removal PR decides.

Two independent facts make the route a dead end on this kernel; every further variant would cost tries for a console we do not need now; the one-way window already gives the vendor kernel's facts, and the mainline kernel's own ACM function is the console that matters.

Rejected: n3r2 with CDC header/call-management/ACM functional descriptors in FunctionFS (f_fs rejects them); a vendor-class interface bound by usbserial generic new_id (needs host root writes through lab-prepare for a console we do not need yet); more FunctionFS tries.

2026-11-17

Our gadget reached the host for the first time (n2: 1d6b:0104 with our strings after 18 s, no panic); cdc_ncm failed on 'failed to get mac address' because the NCM function cannot be given its addresses on this kernel (the attribute writes panic it, so it serves none). The vendor config has ECM, RNDIS, EEM, ACM and SERIAL NOT set, so ecm/rndis variants (walleye-gadget-host-bind as queued) are impossible and dropped. Order: (1) m1, a mass_storage gadget (in the kernel: MASS_STORAGE=y) exporting a fixed-size file in the ramdisk as a read-only LUN; the init rewrites it in place every 5 s with dmesg, cmdline, mounts, heartbeat; the host reads the raw device with O_DIRECT (a one-way, crude but real log window); (2) a FunctionFS helper (a tiny static aarch64 C program declaring CDC-ACM descriptors on ffs, bridging to a shell) so the host's cdc_acm gives /dev/ttyACM0: research item walleye-ffs-helper, run in parallel and now needed, not a fallback. NCM stays out.

The config facts (research walleye-vendor-kernel-facts-s1-panic) rule out ECM/RNDIS; mass_storage needs only in-kernel code and a file, so it gives diagnostics at once; FunctionFS with ACM descriptors gives an interactive console with host drivers that exist everywhere.

Rejected: Chasing the NCM MAC string (the attribute writes panic the kernel; the function is unusable without them); building ecm/rndis images (not in the kernel); waiting for the UART cable (a purchase) when two in-kernel routes exist; adbd from the Android system (bionic userland, heavy).

2026-11-17

Order for the keeper: (1) walleye-load-error-first-state: set-active a, let a's Android finish booting, adb reboot bootloader, the control once; (2) walleye-load-error-restart-host if refused; (3) walleye-load-error-uart with the author's cable; writes (dtbo, vbmeta) come back as new items with their way back after those.

The control on slot a was refused too, so the slot flags alone are out; the only accepted image was tried from a phone that had booted Android on a normally, and that state (a successful=yes, bootloader entered from Android) is the one thing not repeated since. It writes nothing and set-active b is the way back.

Rejected: Flash a stub dtbo or vbmeta now: no way back for the stock dtbo and no evidence it is the cause. Change the image again: the Lineage control already fails with a stock header. Treat the string as one fault: reports show restart, cable, set_active and reflash all cure it, so each is a separate small try.

2026-11-17

ml1/ml2 are packed from the control's header, offsets and AVB footer with our kernel (v7.3 + QCOM_WDT=y), our -@ dtb with a watchdog@17817000 node, and init-ml (mass_storage window, serial walleye-first-boot, product 'Pixel 2 walleye (mainline)', /dev/watchdog opened and never petted). Command line: earlycon=msm_serial_dm,0xc1b0000 clk_ignore_unused ignore_loglevel panic=5 plus the stock androidboot.* words; the vendor-kernel words (lpm_levels, msm_rtb, swiotlb, service_locator, ...) are dropped. Proof: tests/host/mainline-light-up.sh (USB strings, no host permission).

The item asks for exactly these parts; mainline v7.3 msm8998.dtsi has no apss watchdog node and QCOM_WDT was a module (the initramfs has none), so without both the phone could not return by itself. The watchdog address/bark SPI are the downstream MSM8998 values, not measured: if the node faults the kernel panics and panic=5 resets, which also returns.

Rejected: qcom_wdt.arm_on_probe=1/reboot=w (porthole's out-of-tree patches, no mainline effect); keeping the vendor cmdline (vendor-only options); a network function (ncm attribute writes panicked the vendor kernel, and the host has no ECM/RNDIS)

2026-11-17

The gadget inits drop every write to functions/ncm.usb0 attributes (dev_addr, host_addr, qmult, ifname). Build ncm-noattr images in steps b1 (mkdir function), b3 (config + symlink), c (UDC bind, usb0 up, telnetd); the device-side MAC is set afterwards with ip link. Fall back to FunctionFS with a static helper only if bind panics.

In the wahoo 4.4 source the ncm net_device is made at UDC bind, so before it the attribute stores dereference NULL and after the symlink they return EBUSY; every image that panicked wrote those attributes, every one that returned did not have a function.

Rejected: FunctionFS ffs helper first: needs new code and a userspace daemon, no gain if ncm works. gsi.rndis/rmnet: needs IPA and firmware at early init, risky. mass_storage read-only: no log stream, host-visible only. MTP/ACC: need a daemon. Patching the vendor kernel's f_ncm: we boot the unmodified control kernel on purpose.

2026-11-17

1) Read the running Android's full /proc/cmdline and chosen/bootargs and the control header cmdline (read-only): is skip_initramfs there? 2) Measure the panic time with the 1 s watcher against a plain-reboot Android-boot time. 3) Run gadget4 (idle init) only if skip_initramfs is absent. 4) After a panic try, boot Android, ask the author to unlock once, read /data/vendor_ce/0/ramoops as root before any further reboot. 5) If still dark, the author buys the Android Debug Cable (USB-C passthrough + FT232) and the keeper runs fastboot oem uart enable (way back: oem uart disable).

A system-as-root phone ignores a swapped boot ramdisk when the cmdline has skip_initramfs, which would explain no gadget ever and costs only reads to check; the panic time decides between a kernel-side 60 s timeout and an early fault; ramoops survives the warm reset but the vendor service consumes it, so the unlock is the one hand needed; UART answers everything but is a purchase and a bootloader setting.

Rejected: UART first: sure but a purchase and a persisted bootloader setting before the free reads. A dtbo or kernel-cmdline write to move the console: a write with no need yet. Rebuilding the init again (gadget5) before knowing the ramdisk runs: spends tries on a guess. /proc/last_kmsg: gone since Android 6 (console-ramoops instead).

2026-11-17

dt/msm8998-google-walleye.dts: ramoops@a1100000, reg 0xa1100000 size 0x200000, record-size 0x80000, console-size 0x20000, no pmsg or ftrace; PSTORE_CONSOLE and PSTORE_RAM stay =y. No other carve-out in our dtb reaches 0xa1100000 (the highest ends at 0x95800000).

Lab research walleye-vendor-kernel-facts-s1-panic: the phone's ramoops is 0xa1100000, 2 MiB, record 524288, console 131072; a log written at 0xa1810000 is not read by Android. Checked on the built dtb by fdtget/fdtdump in build/build-ml3.sh.

Rejected: Keeping 0xa1810000 (taimen/porthole value): Android would not parse it. Keeping pmsg-size 0x80000: the vendor values have none, and it shrinks the console zone. Reading /sys/module/ramoops/parameters on the phone: a builder never touches the phone; the facts research already holds them.

2026-11-17

1) Leave the flags as they are now (b current and successful, a unbootable but successful, its image untouched and known good: Android ran on it and was measured); no set_active now. 2) Further 'devlab fastboot boot now' tries run with b as the active slot. 3) The keeper reads devlab's before/after slot report on every try and records it with the phone's full fastboot text. 4) devlab's 'set-active now SLOT' (metadata only: priority, retry, flags, partition GUIDs, boot LUN; undone by set_active back) is allowed for exactly one purpose: when a try leaves no good active slot (current slot unbootable, or Android not reachable), the keeper makes b active again (b is the tries' slot; a stays the untouched reserve), and a only when the author wants Android on a. [fastboot] slot_switch = true in the lab's device.toml; writes stays false. 5) Nothing is flashed or erased: a stub dtbo (id 2704, which the Pixel 2 XL bootloader needs) is a write with no known way back (fastboot cannot read the stock dtbo) and stays the author's decision, to be asked only if the tries show the bootloader refusing our kernel for that reason. 6) Next try variants are the builder's: header os_version and patch level set (ours are 0), panic=10 kept (a hang needs hands).

Research walleye-slot-flip-why: a failed fastboot boot on the active slot makes Qualcomm's ABL flag it unbootable and switch to the other successful slot, which is what we saw; the kernel probably never ran. set_active is metadata only and reversible, a and b both boot Android and fastboot stays reachable, so the way back is on record (a two-way door).

Rejected: set_active a now (a stays successful=no, the next failed try flips it again, a write for nothing); set_active before every try (a write per try); flashing a stub dtbo now (no known way back: the author's decision); waiting for the author (the flags are reversible and the way back is recorded).

2026-11-17

The keeper may run devlab fastboot set-active now a (metadata only), try the LineageOS control boot.img once on slot a (the state of the very first tries), record devlab's before/after report and the full fastboot text, and then set-active b if the phone ends in fastboot on a failed slot, so the phone ends as it is now (b current and successful). No flash, no dtbo or vbmeta write. Extends walleye-slot-flags-tries-on-b.

The control (a real stock-format image) also gets Load Error on b with a unbootable: the one change from the first tries is the slot state; set-active is metadata only, a's image is untouched and both slots boot Android, fastboot stays reachable - a recorded way back.

Rejected: Flashing a stub dtbo or vbmeta (no known way back); waiting for the author (a two-way door: the lane's call); leaving the slot question open while only researching (a cheap test answers it).

2026-11-17

No image goes to the phone without a recorded way back that needs no hands. Outcomes of a vendor-gadget try: (1) gadget up: the keeper explores read-only over telnet and ends the try with the init's own reboot (sysrq b / reboot -f) which boots Android on slot a (a is successful), then adb reboot bootloader; (2) kernel panic: the bootloader falls back to Android on a after ~75 s (seen with s1); (3) a silent hang (no panic, no gadget): the init arms a self-reboot timer (reboot -f after 240 s unless a file /tmp/hold exists, which a telnet session may create) - so no hands; (4) a hang before init or in the kernel: the Qualcomm watchdog bites and the phone restarts into a (the s1 case). Hands (hold Power 10-30 s) remain only for a phone that neither panics nor resets (a kernel hang with the watchdog off), and for images that boot a mismatched Android (the stock-ramdisk control images: stopped for good). A try is announced to the coordinator with this table filled for the image.

The author held Power three times today for the same pattern (the control-style images boot Android with a system of another build and stick on the logo); the init that never exits would add a fourth kind unless it reboots by itself.

Rejected: Asking the author for each hang (his attention is the scarce resource); an init that exits (panics, but falls back in 75 s: acceptable only as the last way); controlling power from the lab (no power control exists: a USB power switch or relay is a purchase for the author).

2026-11-17

Before any more tries of our own mainline images, add the method's step 3 at its cheapest: take the control (LineageOS walleye boot.img, accepted from the first state), change only its ramdisk to our gadget initramfs (172.16.43.1), keep its kernel, dtb and cmdline, and fastboot boot it from the first state. If the gadget answers, read cmdline, ids, reserved memory (ramoops, cont-splash), rails and USB mode from the running vendor kernel, read-only, and record them; only then our mainline image e/b, with the ramoops address and dts facts taken from what was read. The UART cable stays queued in parallel as the feedback channel of last resort; its oem decision is unchanged. The failing test walleye-gadget-up (by manifest serial, never VID:PID) is the proof of every step.

Every sibling (OnePlus 5, Mi 6, Pixel 3 XL, taimen) had a feedback channel or a known-good first; the lane has run no kernel on this phone and its one accepted image gave no sign of life. The ramdisk swap needs no kernel build and no write to the phone, uses the one image format the bootloader has accepted, and separates 'the bootloader accepts and starts it' from 'our kernel and dts are right'. It also yields the facts our dts guesses (ramoops address, simplefb, USB mode) from observation. Confirmed by main while this was written: our images e and b were accepted from the first state and neither started (walleye-own-images-e-b-first-state), so a second silent mainline try tells nothing more.

Rejected: lk2nd / second stage: no msm8998 target, device list ends at msm8996, stock bootloader here is ABL not LK, maintainer closed a newer-SoC request; a port is very high cost and unproven under ABL. U-Boot under ABL (sdm845 path): no msm8998 port known, high cost. Building the vendor 4.4 kernel from GPL source: medium cost, unneeded while the Lineage image already holds a built one. Full Halium/Droidian/Ubuntu Touch install: high cost, forum reports for walleye poor, little for mainline. Going straight on with our mainline images (pmOS sibling practice): failure there tells nothing; ordered after the known-good. UART first as a gate: needs the author's hands and an oem command whose persistence is unknown (a change to the phone); kept parallel, not blocking. Flashing boot_a or a stub dtbo: writes, the author's word; only if the control and the swapped image both still end in Load Error.

2026-11-17

The x images are wpa with one group made equal to ours, by fdtput node removals and property edits on the dtb; a node the dtbo overlay targets is emptied, not removed. The groups change disjoint lines; xa (all groups) differs from ours only in pinned lines.

wpa is the alive tree closest to ours (same properties as pk2), so each group is a small, named change; keeping the overlay merging keeps the bootloader's step identical across images, so only the group can change the outcome.

Rejected: A dtb merge tool that rewrites phandles by path (days of work, new code to trust); source-level splicing (ours and porthole's trees have different bases); removal from ours again (d1..d6 did that: all dead, uninformative); starting from pk5 (further from ours: more groups per image).

2026-11-18

Build images from pk5 (alive) that take on the walleye dtb's differences group by group; wa is the whole difference at node and status level

Research walleye-overlay-enables-what-result: the overlay does less on our dtb than on the taimen dtb, so neutralizing its labels cannot find a missing thing; the base differs by 15 disabled nodes and ~100 absent ones, the same for porthole's own walleye dtb

Rejected: Images L1..Ln (our dtb, overlay labels pointed at dummies): the overlay adds nothing live to ours that taimen lacks. More subtraction from our dtb: 13 boots found nothing.

2026-11-18

dt/msm8998-google-walleye.dts gets &tlmm gpio-reserved-ranges = <0 4>, <81 4>, with a comment naming its source (the alive taimen dtb, porthole's dtb, and the x1 bisect). Images y1 and y2 are ml6a plus that one dtb change.

Of 16 boots in the fdt bisect, x1 (the property removed from the alive tree) was dead twice and x2-x7 alive: the property is the cause. One change keeps the effect attributable (the item's own rule).

Rejected: Adding restart@10ac000 (qcom,pshold) and the apps watchdog now: x4 was alive without them being ours, so the finding does not say they matter; they come after y1/y2 are read. Putting the property in a separate overlay or only in the image's dtb with fdtput: the source of truth is our dts, which the images must be built from. Changing the ramdisks or command line: they are the proven ml5a/pk5l ones, unchanged.

2026-11-18

Build wp1..wp5 (one group each) and wpa (all five), tried wpa first

Only five groups: one try per group costs 12 boots, the same as two halving rounds, and shows interactions through wpa; wpa also tests the premise that the cause is a property at all

Rejected: Binary-halving images (g1+g2 / g3+g4+g5): five groups do not need them. The mirror images o1.. from our dtb: only if wpa/wp1..wp5 leave the cause in a group ours alone; our dtb's diff to wa is not yet measured

2026-11-18

The gate of the pstore tries ("run only after a kernel has shown life") is met: the g1 and g2 tries of pk5-stages (lab PRs 114 and 116) returned at ~108 s and 138 s, i.e. our init held its 60 s, so our mainline kernel with porthole's Pixel 2 XL device tree runs and executes our init; only its USB gadget does not enumerate. The pstore T1 try (deliberate panic after 20 s, ramoops at the phone's own region) may run now; its result separates 'the console of a living kernel survives a panic reset' from 'it does not'.

The timing bins alone are not an observation of the kernel, but a return at 108 s or later cannot be a dead-kernel reset (those return at 69-78 s): an init that holds 60 s ran.

Rejected: Waiting for a USB light first (the gadget does not enumerate, so the gate would never open); lifting the gate silently without a record.

2026-11-18

The pstore chase (T1, T3, ml*, pk*) is paused: after many images, no witness of our mainline init exists without a UART, and every further pstore try is read through the same doubt (T3: back at 42 s, no marker: no bite, a lost ramoops region or no init cannot be told apart). Instead the working vendor kernel is used as the INSTRUMENT: our init on the vendor 4.4.302 kernel (proven: m1 enumerates and its window is read by the lab user) mounts debugfs and dumps what the mainline device tree needs into a larger log window: the running device tree (/proc/device-tree, merged with the overlay: the walleye hardware as the phone itself describes it), clk_summary, regulator_summary, pinctrl/gpio state, interrupts, iomem/ioports, the USB controller and PHY state in peripheral mode (dwc3 debugfs, the phy registers' bound clocks and regulators), the reserved-memory map, the PMIC/SPMI devices, the dmesg of that boot. These are facts from the running hardware (GPL kernel, observed behaviour), the clean-room wall holds (no blobs read). They give the dwc3/phy/regulator/clock nodes that mainline USB needs, so the mainline gadget can enumerate: the first real light. The UART cable stays the proper channel and is the author's purchase.

Each pstore try is a one-bit answer through a channel we cannot verify (the same empty pstore means no bite, no region or no init); the vendor kernel is alive, verified and readable through the lab-prepare window; the facts it holds are exactly what mainline USB lacks.

Rejected: More pstore images without a witness (T4 pon notifier, further watchdog variants); waiting idle for the UART cable.

2026-11-18

Order of tries for the pstore question: T1 sysrq c with panic=5 (expected empty, measures cause B), T3 unpetted kpss-wdt bite (expected present), only then T4 a PON reset-type reboot notifier patch. cmdline reboot=w alone is not a try worth an image slot beyond T1 (PSCI has no RESET2 here). None of it before a kernel has shown life.

msm_restart_prepare of the vendor kernel shows plain reboot is a PMIC hard reset and only panic/dload/commanded reboot are warm; mainline sets no reset type and psci runs before the watchdog restart handler; the bite is the one warm-capable path already in our dts and init.

Rejected: A PON reset-type kernel patch first: more work and the register values are not yet read from source. reboot=warm first: needs PSCI 1.1 SYSTEM_RESET2, not present as far as known. Reading more of the empty pstore on stock Android: it cannot tell a missing kernel from a lost region.

2026-11-18

devlab kernel install refuses a kernel that is not an EFI executable.

The bootloader starts EFI programs only; a gzip kernel was lost before it could log a line.

Rejected: Documenting which file to pass.

2026-11-11

devlab health waits until the phone has been up 90 seconds before checking, saying so once.

Every job slept before a health check by hand (7 times); a check read too early fails for the wrong reason.

Rejected: A fixed sleep in every script; checking at once and retrying failures.

2026-11-11

A listening test runs only with --placed, the word that the microphone is by the phone.

The first results came from a microphone being worn.

Rejected: Un-naming the microphone's file as the safeguard: a trick only its author remembers.

2026-11-11

devlab kernel try waits for a new boot id and reports the outcome itself, judged from the running release, the entry's counter and the timeout log.

Booting a test kernel and reading what happened was the heaviest manual work (9 times, 54 effort-minutes), and guessing at it cost three reboots.

Rejected: Waiting for the phone to go down and then up (it misfired twice: the try schedules its reboot); leaving the reading to a person.

2026-11-11

lpoco-bringup image pack/info/unpack/check use abootimg-oxide for the v0 header (parse and write); our code adds the v0 id (SHA-1 over kernel, ramdisk, second with sizes) and the page padding. mkbootimg stays the oracle: the test bringup-pack-matches-mkbootimg builds the same image with it (plain header and with os words) and compares bytes; it skips as 'not measured: no mkbootimg'. The header facts come from device.toml [boot] (deviceinfo words), read by the bringup library (devlab's reader ignores the table until it needs it). check prints one ok/FAIL/not-measured line per fact and exits 1 on a miss; info and unpack.boot.toml print the header as a [boot] table (offsets from base 0), so unpack then pack round-trips.

The research measured the crate's header bytes equal to mkbootimg's; the two gaps are small and proven by test. Native Rust pack means no Python or android-tools needed at run time, and the oracle test guards it.

Rejected: Wrapping mkbootimg for pack: only needed if the crate were not byte-exact, and it would put a python tool in every run. Writing the 1632-byte header by hand: the crate already does it and also parses v1-v4 for later items.

2026-11-17

WHERE: one place for tools that bring a device up - linux-phone-oco/lab-tools, which already says it holds "tools for bringing up and testing Linux phones, not tied to one device". A new workspace member `bringup` (a library with a binary), beside devlab, health and tone. Not a new repository (lab-tools has the CI, the release-plz and the package conveyor; the device template already points there), and not devlab subcommands (devlab is the phone-facing tool - fastboot, ssh, keeper lease, MCP, tokio and rmcp - and building an image needs no phone, no lease and no network; the boundary stays: bringup makes files on the host, devlab puts them on the phone). devlab may call bringup's library later (kernel try building its own image); it does not grow image code. NAME AND ONE ROOF (the author: all tools of lpoco under one roof): one command, `lpoco`, with the family as subcommands - `lpoco bringup ...`, `lpoco health ...`, `lpoco lab ...` (today's devlab), `lpoco tone ...`, `lpoco mcp` - as git and cargo do: `lpoco` is a small dispatcher (argenv) that finds the program lpoco-NAME beside itself or on PATH and runs it, so every tool is still its own crate and binary in lab-tools (lpoco-bringup, lpoco-health, lpoco-lab, lpoco-tone) and can be run alone. One roof buys one install, one pin (device.toml [tools] lpoco = "X.Y" names the whole family), one completion and man page, one MCP server (`lpoco mcp`, the tools of every subcommand under their subcommand's name), one place agents look (`lpoco list`). The family is released together: one version, and the dispatcher stops with a line naming both versions when a subcommand's version differs from its own (nothing half-upgraded runs). The phone's lpoco-health stays its own small static binary - the dispatcher is not shipped there and the phone carries none of devlab's tokio or rmcp. Old names stay as other names for a while - devlab = lpoco lab, devlab-health, the MCP tool names - so the ~450 references are swept over time and nothing breaks at once (as lpoco-health kept devlab-health). The new tool is born under the roof: the crate and binary are lpoco-bringup from its first commit, the dispatcher first or in the same change. The plain word is the method's own (bring-up-a-part); no acronym. SHAPE: Rust, command line declared once with argenv (as lpoco-health), wrapping and not reinventing: mkbootimg, unpack_bootimg and avbtool (android-tools, found on PATH, the oracles) for what only they do well - the AVB footer first - and crates for the rest (a header layer such as abootimg-oxide if its v0 write is byte-exact; cpio, flate2, lz4_flex, xz for the initramfs and kernel container; dtoolkit or fdt to read the appended dtb). Our own code is the part nobody has: the checks against the device's expected fields, the swap of one part against a control image, and the reproducible initramfs. The packer is proven against mkbootimg byte for byte by test, so a later Rust writer replaces the wrapped call without changing a result. FIRST COMMANDS: bringup image info|unpack|pack|swap|check (header v0 first; the swap takes a control image and one part - ramdisk, kernel, dtb, cmdline or a header field - and says what differs; check counts the fields the device's [boot] expects and stops the job on a miss); bringup initramfs build (a newc cpio with fixed times, a template variable for the USB-gadget address instead of the sed rewrite, xz or gzip by the device); bringup bisect FILE (a declared series of swaps against stock). AVB hash footer with algorithm NONE and the control's size and properties is part of pack and swap. Not first: vendor_boot and header v3/v4 (read-only at first), a native AVB, QEMU selftest. STAYS SHELL, stupid simple: build-kernel (a make call with the config) and build-busybox are a few lines each over a strong tool (make); they stay in the device repository, as thin as they are, shellchecked. rust-script is for one-off analysis of a boot image or a log (decision 2026-11-17-health-checks-shell-and-rust); a rust-script that is used a second time becomes a bringup subcommand. tests/host/gadget-up.sh, a host-side check that the phone's gadget answers, belongs with devlab (it is about the phone) and is a later item. HOW DEVICES CALL IT: the device's facts move out of the scripts into device.toml, a [boot] table in pmOS deviceinfo's words (header_version, base, kernel_offset, ramdisk_offset, tags_offset, second_offset, pagesize, os_version, os_patch_level, cmdline, dtb = appended, kernel_compression, ramdisk_compression, avb_footer, partition_size). The device's build scripts become one line each (bringup image pack, bringup initramfs build, bringup bisect), then go away where one command says it; the device template names bringup in its AGENTS.md and ships the [boot] table with every value marked CHANGE, like [flash] and [fastboot]. BUILD: queued as backlog for a builder with the first failing test (bringup-image-v0, proof bringup-pack-matches-mkbootimg); this session builds nothing. HOW A DEVICE USES, EXTENDS, SENDS BACK AND PULLS (the author's rule: side by side, no rebase each time): the tool is followed by a version pin, never copied. Pin: device.toml [tools] lpoco = "X.Y", the family's one pin; lpoco refuses a different version with a clear line (an explicit stop), and installs from a released host binary or cargo install --git --tag bringup-vX.Y.Z (bringup-release settles which is simpler). Extension, never an edit of the tool, in three levels: data ([boot] and the files it names), hooks (executables the manifest names for a step; shell where stupid simple; a nonzero exit stops the job), logic (a rust-script file or small crate in the device repository that depends on bringup's library at the pinned tag). The device's parts are its own files, so a pin bump touches none of them. Sending back: a generic improvement is a pull request to lab-tools from the device's branch, recorded in the device base as an upstream item (form patch, ready on the author's word) against a lab-tools upstream row seeded in device-template beside idealkb and device-template. Pulling in: the weekly pin bump (idealkb's update-pins learns the [tools] line), one pull request per source, the device's CI answering. Same rule for devlab and lpoco-health: lab-tools tools are followed by pin. The files that go with the tool (the [boot] skeleton, hook examples, an initramfs skeleton) travel in device-template's slice by follow.sh as today. RHIZOID: it carries two cases and lacks three things, none worked around. Its cases: a slice (slice-consumption, the template files) and a cutting (a device that must patch bringup itself before upstream takes it: a cutting of lab-tools, tracking branch pristine, patch branch merged, consumed as a cargo git dependency with [patch]; rare, because the three levels cover most). What it lacks, filed on its own backlog (git-rhizoid.github.io PR 28): cutting-as-cargo-dependency, followers-one-pin-bump, send-back-writes-the-upstream-item. Until it has them: follow.sh and update-pins for slices, a plain fork and a [patch] line for the rare cutting.

Walleye wrote eight shell scripts (~520 lines) in a day, the bisect one alone 87 lines of sed, od and grep over unpack_bootimg's output, and surya's was done by hand: every new device would write them again, and their checks (a count that exits 1) are exactly what a typed tool does better with tests. The author's rule is shell only where stupid simple and a strong tool stands behind it; these scripts are logic (header fields, offsets, a dtb found by magic bytes, a footer copied from a control), so they become Rust, and the two that are only make calls stay shell. Earlier decisions already point here: backlog rust-toolset (one Rust toolset in lab-tools, surya is the test subject and not the mould) and 2026-11-17-health-checks-shell-and-rust (Rust for logic, shell for readings, rust-script for one-offs). The landscape (research bringup-tools-landscape) shows nothing covers the job - pmbootstrap does not build the image and is ~24k lines of Python, magiskboot is GPL and aimed at rooting, abootimg-oxide has the header but no checks, no swap, no footer - so wrapping the oracles and the crates is cheaper and safer than writing a packer first. The name: the author offered linux-phone-oco-bootstrap-helpers (lp-oco-bh); "bootstrap" is pmbootstrap's word and the compiler world's, and means something else to every reader; "helpers" says nothing; five words and an unpronounceable shorthand do not suit a command; lab-tools' names are one plain word each. A tool's logic is compiled and versioned, so the follow problem for it is a pin, not files laid into the follower; keeping the device's own parts in its own repository beside the tool makes the rebase question vanish rather than solved (research bringup-home-follow-and-rhizoid). It reuses the one pin-and-follow mechanism decided in idealkb's chain-follow-by-slice and the upstream-item flow already used, and keeps rhizoid for what it was made for. The name was weighed again as a family (research bringup-family-names): git-*, cargo-* and pm* (pmbootstrap, pmaports) are prefixes of tools others install, and a prefix is what makes them findable by completion; a bare plain word is safe only inside one machine. The author asked for a distinctive family.

Rejected: A new repository (a second CI, release and package conveyor for one crate; lab-tools is already where the device template sends people). Devlab subcommands (devlab would take build-time crates and a second job, and its 5.4k lines already carry the phone's whole life; an offline tool should not need a phone manifest's fastboot section to run - it reads only [boot]). Growing the shell scripts into a shared shell library (the pmbootstrap path: more shell, hand-parsed text, no tests, nothing a second device can share by name). Python (refused). Porting mkbootimg and avbtool into Rust first (cost before need; the byte-for-byte test lets it come later). Taking magiskboot or pmbootstrap as a dependency (GPL and rooting-aimed; Python sprawl). Names: linux-phone-oco-bootstrap-helpers and lp-oco-bh (bootstrap means pmbootstrap or a compiler's; helpers has no meaning; too long and unpronounceable), bootstrap, bootkit (a malware word), bootimg (a crate's name and only half the job), imgtool (mcuboot's), mkboot, forge, kit. Shorthand: none - bringup is the short form. For the home: tools as a slice of files followed into each device repository (compiled logic copied everywhere; every device edit becomes a rebase); every device a cutting (fork) of lab-tools (drags the whole workspace into each device repository, and a device cannot follow two forks); git subtree or submodule (a prefix and a second checkout the device never needs); a plugin loader that runs device code inside the tool (a second language boundary; the hooks and the library cover it); waiting for rhizoid to be implemented (its CLI is stubbed and its consumption side open; the need is now). Family question: no prefix at all (bringup, devlab, tone: three plain words, but tone and bringup are ordinary words that collide on crates.io and on other people's PATH, and nothing says whose they are); a prefix on everything now (renaming devlab touches ~450 files, the installed path and the MCP tool names, and the name lpoco-devlab stutters; renaming tone buys nothing while it is not installed); a suffix family like systemd's *ctl (lpoco-ctl names nothing); a short prefix lp- (lp is the printer). Words: lpoco-bootstrap, lpoco-bh, lpoco-bootkit, lpoco-images (see the first list), and a short alias `bringup` beside lpoco-bringup (two names for one tool, which is what the family is meant to end). One roof, the forms weighed (research bringup-one-roof): prefix only, lpoco-* each on its own, devlab and tone deferred (the 2026-11-17 first amendment: findable by completion, but no one install, one pin, one MCP server or one place to look); all tools renamed lpoco-* now and released together with no dispatcher (the same missing roof, and a pin per tool); one fat binary holding every tool (the phone's lpoco-health must stay small and static - it would carry devlab's tokio and rmcp - and a crate per tool is what lets each be tested and run alone; a feature-gated single binary can come later if the dispatcher proves too thin); a hard rename with no old names (breaks ~450 references and the MCP names in one change).

2026-11-17

Install lpoco and lpoco-bringup on a lab host with cargo install --locked --git URL --tag lpoco-vX.Y.Z lpoco, and --tag lpoco-bringup-vX.Y.Z lpoco-bringup (README, Install on a lab host). release-plz tags every package of a release on the one release commit, so the tags agree and the versions match.

Proof bringup-installs-from-tag (lpoco/tests/install_from_tag.rs): into a clean root, from GitHub's tags, lpoco --version is the tag's version, lpoco list shows bringup, and bringup refuses a wrong pin (exit 2). It passed in CI. Cargo already resolves the tag, the lockfile and the toolchain; nothing new to maintain. Found on the way: tags of 0.1.7 sat on different commits, so only a version released after the pin (0.2.0) installs a family that works; and the release made the old wrong pin 0.2 right, so the wrong-pin tests now use 99.0.

Rejected: Host binaries as release assets (x86_64 linux, checksum): a build job, a checksum step and a download script for a lab that already has cargo; revisit when a host without a toolchain needs it. One shared family tag: the conveyor reads lpoco-health-v*, see 2026-11-17-lpoco-family-version.

2026-11-17

[boot.hooks] parts = EXE (relative to the manifest) is called with the kernel and ramdisk paths in a scratch folder; what they hold afterwards is packed. A missing or non-zero hook stops the job (exit 2, nothing written). The pin [tools] lpoco = "X.Y" is a version prefix checked before any verb that finds a manifest.

Test-first: bringup-refuses-wrong-pin and hook tests in bringup/tests/pin_and_hooks.rs; the ramdisk is the part device repositories change.

Rejected: Hooks editing the user's own files in place: a failed hook would leave them changed. A hook per image field: no device asked for one yet. Skipping the rust-script test when rust-script is absent: a skipped check is not a check; CI installs it instead.

2026-11-17

devlab-health reaches phones as an Alpine package: release-plz tags devlab-health-vX.Y.Z, and the package conveyor's alpine.yml builds it from the tag's APKBUILD, signs it with lab-tools' own RSA key, verifies it and publishes an apk repository on lab-tools' pages for postmarketOS v26.06 (Alpine 3.24), then installs it in a clean container.

One way for code to reach a phone, measured, instead of devlab copying files: the phone updates the suite with the rest of its system, and any postmarketOS phone can take it without the lab. The conveyor already did this for pacman; the Alpine path was its open cv-apk.

Rejected: Keeping devlab suite put as the only way (files no package manager knows, nothing for a phone outside the lab); building in lab-tools' own CI (copying what the conveyor keeps once); a key shared across the commons (keys stay per project for now); publishing as release assets (apk needs an index under a stable path).

2026-11-17

A change devlab makes to the phone ends with its health: after a reboot (phone reboot, kernel try) devlab waits for the report that boot writes by itself, rather than running the suite again; after a change without a reboot (provision) it runs the suite now. Either way the report is brought to the lab and an unhealthy phone fails the command.

Nobody has to remember to check; and waiting for the boot's own report measures exactly what every boot of the phone measures - the lab adds no second way of checking.

Rejected: Running the suite from the lab after each reboot (two runs per boot, and the lab's run would be the one that differs from an unattended boot); leaving the health check as a separate step to remember.

2026-11-17

device.toml [fastboot] serial (as fastboot devices lists it) and writes (default false). Every fastboot call devlab makes passes -s SERIAL; devlab flash refuses a phone without writes = true; devlab fastboot offers only reading, boot from memory and reboot - no flash, erase or set_active verb. The guard refuses raw fastboot other than devices, getvar and help.

A second phone (google-walleye) sits in fastboot on the lab beside surya: devlab flash checked any phone in fastboot and flashed without -s, so a surya flash would have written to walleye. walleye's slots must stay as they are until a recorded decision (walleye-fastboot-first); a default of no writing makes that the phone's state, not a rule to remember.

Rejected: writes defaulting to true (a manifest that forgets the line would let walleye be flashed); a flash that takes the only phone in fastboot when there is one (true today, false the moment two are); a separate fastboot tool beside devlab (the lease, hold and guard are devlab's, one way per phone); writing surya's serial from its soc0 serial (3693150539 = dc21014b) unread from fastboot: not known yet is said as not known, so surya's flash refuses until a keeper reads it.

2026-11-17

devlab files the phone's reports into the picture through tad (one tad sql statement per run: its rows read from the report, its counts from those rows; tad keeps it only if every rule holds, then canonical form and the rendered pages), and devlab watch, after every boot, waits for the phone's own report, says its verdict on the board, and gathers with --land: in devlab's own clones of the lab and the picture, each landed through land, signed devlab. The face is drawn again by the picture's CI on that landing.

The author, 2026-11-17: tad is the open database shared by the whole linux-phone project; devlab reports the suites' results into it by itself and the pages reflect them - not an agent doing it by hand each time. devlab's own clones keep its landings out of the clones people and agents work in (two hands in one clone once merged each other's changes).

Rejected: devlab appending JSON lines itself (rows tad never checked); the watch running the lab-side checks over SSH (a second way of measuring beside the phone's own); landing from ~/Projects (collides with work in progress there).

2026-11-17

devlab gather now brings every report the phone keeps that the lab lacks into the device lab's tests/results (RUN.jsonl, as written on the phone), and files every run not yet filed into linux-phone-oco/docs' test_results and test_runs, the rows made from the report's lines. A run is filed once, by its id.

Filing was by hand (tests/to-docs.sh, through tad's Python) and had fallen a week behind: docs held 7 runs from 2026-11-10 while the lab had made many since. Rust carries it now, and the tables stay where they are declared and observed today.

Rejected: Declaring test_runs and test_results again in each device lab (one nature, two declarations - entered as the sign a-test-run-has-no-shared-shape in ocoeco, to be answered in the language); keeping to-docs.sh (new filing through Python).

2026-11-17

devlab guard keeps only the phone's way: ssh, scp, sftp, rsync and sshpass to a phone outside devlab are refused (devlab guard tool, PreToolUse). The ways every project shares - no git push to main, no Python, the practices and the inbox at session start - moved to the ideal-agent plugin's hooks (grenudi/ideal-agent), installed on the lab; devlab guard start is gone and the lab's settings keep only the PreToolUse hook (lab-tools #65).

The author, 2026-11-17: general agent know-how has one home, grenudi/ideal-agent (its decision 2026-11-17-one-home-for-agent-know-how). Held in devlab, the shared rules held only on the lab. Before devlab's rules were removed, both guards were given the same 19 events: they agreed on every push and Python case; the one difference was the phone's, which stays here.

Rejected: Both guards holding the shared rules (two guards saying one thing drift apart). Moving the phone's rule to the plugin too (it is this lab's device: its addresses come from devlab's state).

2026-11-17

devlab-health takes analysis as subcommands of its own binary: tone make|find (lab-tools' tone crate, linked with only its wav feature) and data plan|spent (the month's mobile-data ledger, a JSON file in /var/lib/devlab/health-data that pruning never touches). Their arguments are parsed by hand, and each prints one JSON line with exit 0/1/2. A check reads that line with lib.sh's json_field. mobile-data runs every boot in the telephony layer and is bounded by the month's budget, not by once_a_day. It measures the connected bearer that carries a default route and is not IMS. The week's 5 MB run counts as made only when its download came whole.

The tone crate already had tests, and the checks' awk Goertzel had none. Linking the crate costs 64 KiB on the phone, against two copies of the arithmetic. hound was already the lab's WAV reader, so one read_mono now serves tone, devlab hear and the runner instead of three. The research (mobile-data-check-budget) measures data every boot and bounds it by a monthly ledger; a byte count kept across runs is state, which the shell-and-Rust decision puts in Rust. On surya an IMS bearer (APN ims, IPv6, no route) sits beside the data bearer, and the first-connected rule measured it as 0 of 5 pings.

Rejected: clap in devlab-health (size on the phone; argenv is the commons' parser, and moving the runner onto it is its own change). A WAV reader written again by hand (hound is there and tested). Ledger arithmetic in shell (state and numbers, against the shell-and-Rust decision). once_a_day for mobile data (the research measures every boot; the budget already bounds the cost). The first connected bearer (picked IMS on surya). Marking the weekly run as made when it failed (a broken run would hide throughput for a week).

2026-11-17

The phones' health suites keep one contract - a check prints 'pass|fail|skip TEST COMPONENT detail', and docs' tests table says what a pass proves - and two languages by kind of work: shell for readings (sysfs, a command's output, a few readable lines on BusyBox), and Rust for anything with numbers, timing or states (tones, echoes, calls, sleep counters), as subcommands of one static multi-call binary shipped with devlab-health (devlab-health tone make|find, later call echo), unit-tested on the lab with recorded fixtures and cross-built by health/build.sh. rust-script is the lab's tool for prototypes and one-off analysis of recordings fetched from the phone; a prototype that is kept becomes a subcommand. Checks are layered by cost: base, shell, telephony (calls and data, budgeted, at most daily), witnessed (a person). Coverage is a query over docs: every device's components with no test proving works.

The shell contract is what makes a check quick to write and read, and it already runs everywhere; what goes wrong in shell is arithmetic - three of surya's checks carry an awk Goertzel and a printf-built tone that nobody unit-tests, while lab-tools' tone crate has tests and never reaches the phone. The phone has no Rust toolchain, so Rust must arrive compiled; one binary already goes there (devlab-health), so analysis joins it at no new cost. rust-script works today on the lab; Cargo's own scripts are still nightly-only (Cargo 1.99 asks for -Zscript) and can replace rust-script when they are stable.

Rejected: Python checks (refused on the lab; the phone's python3 is the image's, not ours). rust-script or cargo script on the phone (a toolchain and network on the phone, minutes of compiling at boot). Every check in Rust (a ten-line sysfs reading becomes a cross-build per change). bats or another shell test framework (bash, not BusyBox ash; the contract already does its work). LAVA or a KTAP-native harness now (a lab of many boards; our lines map onto KTAP if ever needed). One binary per check (many cross-builds and files to ship).

2026-11-17

The phone measures its own health after every boot: devlab-health, a static Rust runner, runs small check files (base layer, then shell layer) and writes one report per run in test_results' shape, keeping the evidence when unhealthy. The checks are POSIX shell in postmarketOS's test shape and print plain words (pass|fail|skip TEST COMPONENT detail); the runner makes the JSON, the verdict and the evidence. Generic checks live in lab-tools; what a phone is expected to have is its manifest's [health], and a phone's own checks sit beside the generic ones.

Health measured only from the lab is health only while the lab is connected and remembers to ask; a phone that checks itself after every boot leaves a record for every change. Shipped code is Rust (2026-11-11-rust-for-what-ships): strings and structure - JSON escaping, the report - are where shell is fragile. The probes themselves only read sysfs and the system's own tools, which is what postmarketOS's tests and bootrr do in shell, so they can be contributed there.

Rejected: A shell runner (JSON escaping and report shaping in sh - the fragility the Rust decision answers); checks written in Rust (a probe of sysfs gains nothing, and upstream would not take it); keeping the checks run only from the lab over SSH (no record when the lab is not asking); one check file per device (surya's checks.sh: nothing reusable for the next phone).

2026-11-17

The health suite reaches phones as an Alpine package (devlab-health: the runner, the checks, the unit and the timer) published through the package conveyor once it publishes Alpine repositories (cv-apk); until then devlab puts the same files on the phone itself, as the development path.

The commons has one packaging conveyor that every project calls (linux-package-distribution-oco/conveyor) and it already builds aarch64-musl binaries; a package is how postmarketOS installs and updates anything, and it gives the phone updates the way the lab machine already gets them.

Rejected: devlab copying files onto the phone for good (a second delivery route beside the conveyor; nothing updates it); building the package in lab-tools' own CI (copying what the conveyor exists to do once).

2026-11-17

lpoco and lpoco-health (and every later lpoco-*) share one version through release-plz's version_group, starting at 0.1.7 (lpoco-health's). The dispatcher refuses a program whose --version differs, so every lpoco-* program must answer --version with 'NAME X.Y.Z' (lpoco-health now does). Tags stay one per package: lpoco-v{version} for the dispatcher (lab-side only, no phone package) and lpoco-health-v{version} for the conveyor's phone package.

Decision 2026-11-17-bringup-in-lab-tools asks for one version pin for the family and one release; version_group gives it without moving the conveyor's tag prefix. Proof: lpoco-refuses-mixed-versions.

Rejected: One shared git tag for the whole family: the conveyor reads lpoco-health-v* for the phone package, a shared tag would break it. Independent versions per program: the dispatcher could not tell a compatible program from a stale one.

2026-11-17

linux-phone-oco has one health suite, lpoco-health (devlab-health renamed; same checks, same test_results shape, same report on the phone). It keeps the shape decision 2026-11-17-health-on-the-phone chose: small shell checks printing 'pass|fail|skip TEST COMPONENT detail' (postmarketOS's test shape, so a check can later become a postmarketos-test-* subpackage by a merge request), gathered by our static Rust runner. New: (1) detected conditions - conditions/*.sh work out no-sim, no-modem, no-network at every run; checks say skip_on NAME and report 'skip: no SIM card'; nothing is written down. (2) chosen switches - lpoco-health off TEST --reason WORDS [--by], on TEST, list, kept in /etc/lpoco-health/switches (test, reason, who, when), reported as 'skip: switched off: reason (by who, when)'; never without a reason; from the lab devlab suite off|on|list and the MCP tools health_switch_off/on, health_switches. (3) the command line is declared with argenv (health/src/cli.rs). (4) docs hold only facts about the hardware and the results; the phone's state (SIM in or out) is never recorded there; backlog sim-removed-skips closed as superseded, its log entry stays. (5) provisioning: the Alpine package lpoco-health (published by the conveyor since 0.1.6) is what devlab suite put now takes; --runner builds the runner on the lab for what is unreleased; put migrates the old devlab-health reports, month data ledger and once-a-day marks with nothing lost, and the package keeps devlab-health and /usr/lib/devlab/health as other names until the phone's own checks call the new ones. (6) upstream: we do not fork postmarketOS' test pieces now; we write our checks so they could be sent upstream, and revisit when their system-level tests or farm admission exist.

The SIM removal showed that a state of the phone cannot live in docs: it is true for minutes and the phone knows it better. Every mature phone CI (bootrr, LAVA, postmarketOS's test package, CI-tron) keeps tests as small executables with one result line each and a thin runner, device facts as data and an explicit skip; nobody compiles on the device. Upstream postmarketOS (checked 2026-11-17) runs on-device tests only from the initramfs, halting the boot; boot and system tests - the modem, audio, sensors, sleep and budgets we need - are not built, and their farm is one phone behind a token gate. Our checks and runner already have the shape, so it is kept and extended, not replaced (decision 2026-11-17-health-on-the-phone weighed first).

Rejected: A. Building fully on postmarketOS upstream (fork their test pieces into a rhizcut-synced subfolder, send improvements back as merge requests): the right long-term friend - open GitLab, clear review rules, Python only host-side so it does not weigh against it - but today it gives us only the initramfs hook, which halts the boot and covers kernel tests, not the after-boot system tests we run; their farm has one OnePlus 6T and registration is token-gated; whether rhizcuts handle a GitLab upstream and a subfolder is not known; licence/CLA and fork-sync cost not known. Revisit when upstream gets system tests or admits other phones. C. A different shape of our own: nothing to gain over B. rust-script tests with a bundle crate (the author's lean, weighed fairly): the dependency direction is right (bundle depends on tests, not the reverse) and nextest shows it works, but rust-script needs rust+cargo on the phone (Alpine aarch64 72 MiB download, 206 MiB installed plus gcc, musl-dev, llvm-libs, network for crates), a registry (inventory/linkme) is unproven on aarch64 musl and links everything into one binary; kept instead: the same direction by discovery - the runner finds tests in directories, tests depend on nothing of it - and Rust for logic (runner, ledger, tone) built on the lab as a static binary; revisit as prebuilt per-test binaries when a check needs more than shell. Building each test on the lab as its own binary now: cross-build work for 13 small shell checks that need none. A settings store in docs or in devlab's lab-side files: wrong place for the phone's state, goes stale. Keeping the name devlab-health: the suite is linux-phone-oco's, not devlab's; the old name stays only as an alias. Lab-built runner by default: the package is published, so the package is the default.

2026-11-17

WHAT: a new program under the lpoco roof, lpoco-host (`lpoco host`), its own crate host/ in lab-tools, Rust, command line declared with argenv. It prepares the lab host for the devices it serves and keeps the host's own tools at their pins, from declarations only: no manual step stays outside it. Bringing a phone up on a fresh host is then: the one bootstrap line (cargo install --locked --git https://github.com/linux-phone-oco/lab-tools --tag lpoco-vX lpoco lpoco-host), clone the lab and device repositories, `lpoco host prepare now`. VERBS: `lpoco host plan` (the default, read-only: a content diff per file, the tools to install with pinned and found versions, and the exact root commands); `lpoco host prepare now` (the only state change: writes, reloads, triggers change only where it touched; `prepare` without `now` refuses); `lpoco host check` (the lab user opens each declared node present; each tool at its pin; fastboot by the device's serial as the lab user). Only plan and check are offered through `lpoco mcp`. TWO DECLARATIONS, one owner each. What a device needs of any host lives in its own device.toml, a [host] table read by lpoco-host alone (devlab ignores it): `modules = [...]`, `[[host.gadget]] serial = "...", access = ["block", "tty"]` (walleye's shape from lab PR 54, kept; deny_unknown_fields inside [host]); later `targets` and `commands`. What one machine is lives in the lab's own declaration, lab.toml at the root of grenudi/lab-machine (that repository already is "how the lab machine is set up"; --lab PATH or LPOCO_LAB elsewhere): where its devices are (default ~/Projects/linux-phone-oco/*/device.toml), its root prefix, and [tools] - each host tool with its source and pin. WHERE THE TOOL PINS LIVE: in the lab's declaration, not in device.toml. A host has one ~/.local/bin, so one version of each tool; land, oco-work and agent-env are the lab's and the agents', no device's concern. device.toml [tools] lpoco = "X.Y" stays what it is - the device's requirement of the family - and the plan checks the lab's lpoco pin meets every device's: a device it does not meet is named and nothing is installed for it. Tools: land (grenudi/lab-machine bin/land at a commit), oco-work (its only tracked home is creation-guidelines/lab-agent oco-agent/tools/oco-work, a retiring place: it needs a living home before it can be pinned), agent-env (grenudi/ideal-agent scripts/agent-env at a commit), the lpoco family from its release tag (cargo install --locked --git ... --tag lpoco-vX for lpoco, lpoco-lab, lpoco-bringup and lpoco-host itself; a self-upgrade installs and stops, the next run is the new one). User-level, into ~/.local/bin, no root; hand copies (devlab.before-*) are not the tool's to keep. ACCESS: per device one file /etc/udev/rules.d/70-lpoco-CODENAME.rules (below 73-seat-late, as uaccess needs), one line per access kind: ACTION!="remove" (systemd 258+ re-applies on change), SUBSYSTEM=="block"|"tty", ATTRS{serial}=="SERIAL" (our own gadget's serial, never a vendor-wide match), TAG+="uaccess". uaccess reaches the lab user while it holds the active seat0 session - true on the lab today, and enough for the acceptance; a lab group with MODE 0660 for a headless host and services is the next item (lpoco-host-rest). Nothing by vendor for adb and fastboot: systemd 262's hwdb tags them; `check` proves it. Applied by `udevadm control --reload` and `udevadm trigger --action=change --attr-match=serial=S`: no replug. MODULES: /etc/modules-load.d/lpoco.conf from the declared modules, `modprobe` each now; when /lib/modules/$(uname -r) is gone the plan says the host must reboot into its installed kernel (what stopped usb_storage and cdc_acm today). ROOT: the tool runs as the lab user and asks root only through one prefix, LPOCO_ROOT, falling back to DEVLAB_ROOT, then `sudo -n lab-agent root-exec --`; it runs only a fixed list of commands the plan prints (install -D -m 0644 into the two paths above, udevadm control --reload, udevadm trigger --action=change --attr-match=serial=S, modprobe M). That list is what lab-agent's retirement part 6 (ideal-agent 2026-11-17-lab-agent-retires-by-parts; lab-agent-6-root-exec-grant) can write a narrow grant or the lab-root wrapper from; the grant stays the author's and root's. LAB-MACHINE keeps what is only this machine's (locale, nix, plasma) and its lab.toml; setup/devlab-watch.sh retires when watchers move into the tool; its README names the bootstrap line. The device template gains a commented [host] table. PROOF: first the failing fixture test plan_grants_gadget_serial_and_changes_nothing, then plan_lists_host_tools_at_pins_and_installs_nothing; acceptance is the tool's first real use (the author: "ill wait for the tool, so its use would be its test"): `lpoco host prepare now` grants walleye-first-boot, and the walleye keeper reads /dev/sda and /dev/ttyACM0 as the lab user. No udev rule is written by hand meanwhile. Backlog lpoco-host (rank 1), lpoco-host-rest. AMENDED 2026-11-17 (the author, through the coordinator: "Keep it for now"): /etc/udev/rules.d/51-android.rules, the wide rule left by lab-agent's connect.sh, stays. lpoco-host leaves it alone: plan and check may name it as a known wide rule, and prepare now neither removes nor edits it.

Principles no-manual-steps and rust-with-argenv. The author, 2026-11-17: "this needs to be on lpoco tools, for preparing the lab, and device repos should have it from the one roof. something like lpoco-labprep or something ... we dont keep manual steps outside tools, so that the process of bringing up linux phones could be fully automatic"; and "ye, ill wait for the tool, so its use would be its test". The coordinator, the same night: the host's own tools (land, oco-work, agent-env, the lpoco family) installed by the tool at pinned versions, nothing copied by hand - ~/.local/bin/land was a hand copy and nothing in lab-machine installs it. Measured (research lab-host-prepare-landscape): after the reboot walleye's gadget bound but /dev/sda (root:disk) and /dev/ttyACM0 (root:uucp) were closed to the lab user, and the fix was handed to the author as a manual rule; 51-android.rules, the cross toolchain, the watcher units, the host tools and the host reboot for missing modules were all hand work. Nobody outside derives host rules from per-device declarations: LAVA comes closest (serials in data, one static rule and a root helper), labgrid leaves rules to the administrator, pmbootstrap runs as root. systemd's source settles the mechanism: uaccess in a rule below 73, not add-only, applied to present nodes by a change trigger; adb and fastboot already covered on 258+. Under the roof (decision 2026-11-17-bringup-in-lab-tools): a crate per tool, run alone or as `lpoco NAME`, one pin, one release; the boundary that lpoco-lab is the phone-facing tool (fastboot, ssh, the keeper's lease, tokio and rmcp) holds - preparing a host needs no phone and must run first on a fresh machine, small. The device says what it needs, the lab says what it is: each declaration with the owner that knows it, as [boot] is bringup's and [health] the suite's. The name is plain and names its object, as health and bringup do: `lpoco host prepare now` reads as what it does.

Rejected: Names: lpoco-labprep, the author's starting word (a clipped compound, the shorthand the roof refused with lp-oco-bh; and `lpoco labprep` beside `lpoco lab` reads as part of lpoco-lab, the phone tool); lpoco-hostprep (the same clipping); lpoco-setup (says nothing of what is set up; setup/ is lab-machine's folder word); lpoco-provision (devlab provision is the phone's); lpoco-bootstrap (refused for bringup: pmbootstrap's and the compilers' word); lpoco-prepare (a verb as a name - prepare what? the verb belongs after the object); lpoco-machine (lab-machine's name); lpoco-env (agent-env's word). Forms: a `lpoco lab host ...` subcommand of lpoco-lab (lpoco-lab carries the phone's life, tokio and rmcp, and a lease; the host must be prepared before any phone and from a fresh machine; the roof keeps one crate per job); lab-machine's job, fed by the declarations (shell parsing TOML and diffing files is logic in shell, which the author's rule refuses; lab-machine describes one private machine, so a second lab would copy it; it keeps the lab's own declaration instead); LAVA's way, one static rule calling a root helper on every uevent (root on every event, rules matching at run time cannot be planned or diffed); a package or a systemd confext image built from the declarations (a rebuild per device change, tied to the host's distribution, while the conveyor builds Alpine packages; possible later as an output); systemd's built-ins alone (cover adb and fastboot, not our gadget's block and tty); NixOS modules or Ansible roles (a second system to adopt on a CachyOS host; Ansible is Python); vendor-wide rules in the shape of 51-android.rules (MODE 0666 to every Google or Qualcomm device on the bus; ours match only our own gadget's serial); adding the lab user to disk and uucp (disk opens every disk on the host); a dedicated group in the first build (needs usermod and a new login before it works; uaccess serves the acceptance now; the group follows in lpoco-host-rest); a udev rule written by hand meanwhile (the author: the tool's use is its test). Where pins live: in each device.toml [tools] (one ~/.local/bin cannot hold two devices' different versions, and land, oco-work, agent-env belong to no device; the device's lpoco pin stays as its requirement, checked against the lab's); in the tool's own code (it would pin what it was built with, so moving land meant releasing lab-tools); a lockfile beside ~/.local/bin (state, not a declaration in a repository; nothing reviews it); following main without pins (a tool changing under a running lane, which the family's one-version stop exists to prevent). Root: running the whole tool as root (whole-command root, as pmbootstrap; the plan and the tool installs need none); editing sudoers from the tool (the grant is the author's and root's, lab-agent-6).

2026-11-17

lpoco mcp runs lpoco-lab mcp. One server lists lab_run/put/get/kernel_*/reboot (the bare names run, put, ... answer the same function), health_* and bringup_image_info/check (which run lpoco-bringup beside it). A new program joins by adding its prefixed tools to that router.

Agents look in one place; the rmcp router already held the lab tools, and prefixes by program name need no second protocol layer. Proof lpoco-mcp-lists-every-family-tool lists them over real stdio.

Rejected: A proxy that starts each lpoco-NAME mcp and merges their tools: a child process per program and an MCP client for no gain while only the lab holds a phone. A separate lpoco-mcp crate: a second copy of the door and its device loading. Renaming the tools with no aliases: breaks every agent's saved config (lpoco-names-sweep keeps aliases until it ends).

2026-11-17

Every test sound is quiet unless the phone's manifest says otherwise: [hear] level_dbfs (default -40 dBFS) and volume (default 25%), capped at full scale and 100%, used by devlab hear and given to every check through the phone's health.env (TEST_TONE_DBFS, TEST_VOLUME).

The author, 2026-11-17, urgently: a full-scale test sine played at night; test sounds must be quiet, with a setting for it in the suite. devlab hear had -12 dBFS at 60% volume hard-coded.

Rejected: Lowering the hard-coded numbers (no setting, and other checks would choose their own); a level per check (a phone in a home has one acceptable loudness).

2026-11-17

fastboot boot now and set-active read current-slot and the slot-unbootable/successful/retry-count flags of both slots before and after, and say the difference; the verdict of a boot is where the phone went, not fastboot's exit. set-active (metadata) is refused unless the manifest says [fastboot] slot_switch = true, separate from writes.

walleye's try b: devlab wrote nothing, yet the bootloader's A/B logic ended on slot b with slot a unbootable, and devlab, reading fastboot's failing exit, called the try refused.

Rejected: keeping 'nothing written, slots as they were' (true of devlab, false of the phone); folding the switch into writes = true (a flag change is not a partition write, and walleye may need one without the other); restoring slot a by devlab on its own after a try (a write that needs the author's word).

2026-11-17

devlab holds the phone for every change it makes - flash, provision, reboot, root commands, put, kernel install, try and remove, suite put - by an exclusive lock on STATE/phone.lock, from the command line and the MCP door alike; a second change waits for the first and says so. Reading needs no hold.

Two sessions now work with one phone (the bring-up session beside the conveyor's): a reboot under a kernel try would strand a test or misreport it. A lock each session must remember to take is a rule kept by care; devlab taking it itself is kept by the tool.

Rejected: flock around devlab by convention (forgotten once is enough; and wrapped around a devlab that also locks, it would wait on itself); a lock only in the MCP door.

2026-11-17

devlab offers its structured door over MCP (devlab mcp, stdio, with rmcp): run, put and get a file, the health report, kernel install, try and status, reboot and wait - each the same function the command line calls.

Agent access plans every tool's structured door over MCP in Rust with rmcp, devlab among the first (aa-two-doors); an agent then works with the phone without a person and without a shell's quoting layer.

Rejected: A separate MCP server project beside devlab (two doors to keep in step); MCP through a generic shell tool (every call a quoting puzzle).

2026-11-17

The ways an agent must keep on the lab (land, not a push to main; no Python; the phone only through devlab) are held by Claude Code command hooks that call devlab guard, a subcommand of devlab in Rust, with its cases tested.

A way that must be remembered is forgotten; the hook refuses when it is tried and says why, to the agent that tried. devlab already knows the phones (their manifests and learned addresses), so the guard knows what reaching the phone means.

Rejected: Hook scripts in shell with jq (logic in shell, untested; the guide says Rust for logic); a separate guard tool beside devlab (a second place that must learn the phones addresses); permission deny rules in settings (match command prefixes only: miss sudo, env, sh -c and $(...), and cannot tell a branch push from a push to main).

2026-11-17

image bisect frames a swapped-in kernel with the lz4 program (level 9, independent 4 MiB blocks, content checksum, the stock kernel's frame flags); an entry may also leave the AVB footer off. The count compares ramdisk, kernel, dtb and command line to the control and verifies the footer; it does not compare the second stage or other header fields.

walleye's build-bisect.sh used lz4 -9 -BI -B7, whose frame the stock bootloader path reads; the oracle is the lz4 program, as avbtool is for the footer (research bringup-tools-landscape).

Rejected: a Rust lz4 crate (lz4_flex): no level-9 high compression and the frame flags would differ from the stock frame, so the bisect would change two things at once; comparing every header field: not needed for the walleye series, narrowed the claim instead

2026-11-18

check-changelog.sh (run by the commit-kind workflow): per package, a changed CHANGELOG.md passes if the [package] version changed since the merge-base, or if it adds the heading for the current version that the merge-base lacked. A lone edit or a repeated version is refused.

Release #111 left lpoco-host without an entry; release-plz put it in a follow-up PR #113 that only changes a changelog, which the first check (#112) would refuse. That PR completes the version, tags host-v0.3.5, and so tags something.

Rejected: Reconfiguring release-plz so unchanged version_group members get an entry in the first PR: no setting for it confirmed. Accepting any changelog-only PR: reopens the changelog-only release #112 forbids.

2026-11-18

pr-title.yml checks the PR title and every commit title against .github/commit-kind.regex, and refuses a changed CHANGELOG.md with no changed Cargo.toml version; lpoco/tests/release_family.rs keeps release-plz.toml, versions and changelog headings whole.

#110 landed titled 'bringup: ...', so release-plz saw nothing to bump and #109 was a changelog-only release under v0.3.4; the code sat under no tag. land squash-merges a one-commit branch under its commit title, so commits are checked, not only the PR title (review).

Rejected: Checking only the PR title: the commit title is what lands. Comparing the changelog with the version's tag in a Rust test: release-plz tags the commit before the changelog is written, so it always differs. release_commits regex in release-plz.toml: does not make an untyped commit bump.

2026-11-18

release-plz.toml gives each package changelog_include = every other member; a fixture-workspace test runs release-plz update and requires every member's CHANGELOG at the new version; CI installs release-plz@0.4.3.

Seen on v0.3.5-v0.3.7: a package changed only by the version_group bump got no entry, so main was red until a follow-up PR (#113, #117, #120). Reproduced with release-plz 0.4.3: without the key fam-b has no entry, with it all three do.

Rejected: Writing missing entries in a release hook: more code than one config key. Loosening the release_family test: hides the red instead of removing it. A fixture with no prior changelogs: passes without the fix, so proves nothing.

2026-11-18

In a git clone, plan/prepare/check fetch origin (no prompts, low-speed bound) and read device.toml from origin/main; a read: line names the commit, the checkout's lag, a differing working file, or why the file as it lies was read.

A stale detached google-walleye-lab clone without [host] planned no udev rule; a stale checkout must not hide the declaration.

Rejected: Reading the working file only (the bug). Following origin/HEAD: main is the lab's only truth, so origin/main is fixed. Fetching only in plan: prepare would then act on a different commit than plan showed.

2026-11-18

devlab/src/cli.rs holds contract! inputs (positionals scoped to the command, flags, the env it reads) and a TREE of commands and actions with their arguments and flags; --help, argument counts and per-action flag checks read it. suite put's --runner [FILE] becomes --runner FILE or --built-runner. Usage mistakes exit 2 with the usage; help wins over a mistake.

argenv scopes inputs to the first word only and has no optional-value flag; the tree restores per-action scoping. Programmer review found sibling-action flags silently accepted and exit codes split 1/2: both fixed.

Rejected: Generic ARG0..ARG4 inputs (help says nothing); keeping clap beside argenv (two declarations of one surface); a hand parser for the optional-value flag (practice 43)

2026-11-18

tone/src/cli.rs holds the contract; main.rs scopes flags per command from TREE, refuses extra positionals and out-of-range or zero rate and channels with the usage (exit 2). Rate and channels are read as u64 and narrowed at the edge; defaults come from the declaration.

The last clap in the family (backlog lpoco-tone-argenv); the practice that every program declares its invocation surface once with argenv; same shape as lpoco-lab so one reader knows both.

Rejected: Reading rate/channels as u32/u16 in the contract: a value that does not fit becomes None and fell back to the default silently (programmer review). Keeping clap beside argenv: two parsers for one program.

2026-11-18

Test kernels are booted from their EFI image (vmlinuz.efi), and the conveyor refuses anything else.

A gzip kernel was chosen by the bootloader, counted down, and could not start - silently, before any log.

Rejected: Sort keys, a stored default entry, a second boot partition - each checked and ruled out.

2026-11-11

The audio pin driver's function slots for the SoundWire pins follow the phone's own Android kernel (gpio19 swr_tx_data in slot 3, gpio23 swr_rx_data in slot 2).

A bus clash on the TX bus came right before the codec's timeout; the driver's table disagreed with the vendor's pin description on exactly these pins; corrected, the codec came up on the first boot.

Rejected: Treating the clocks switching off as the cause; changing the macros' autosuspend.

2026-11-11

Boots that come up without the sound card are measured over a run of reboots before anything is changed.

It happened once in several boots; the audio processor's service channel never appeared. A guess at a cause would be untestable without a rate.

Rejected: Unmasking the helper service masked for the suspend crash, on a hunch.

2026-11-11

With the SIM in, the modem is examined read-only first; switching the radio on is the only change made, and nothing that calls, messages or uses data happens without the author's word.

A SIM card costs money and reaches people; the phone's state stays known.

Rejected: Trying a call or a data connection straight away.

2026-11-11

The capture failure is not chased in runtime power management.

With the bus controllers, macros, codec and SoundWire devices all forced awake, the read failure came at the same moment, the same way.

Rejected: Changing the macros' autosuspend or the controller's clock-stop handling.

2026-11-11

The right channel is the bottom speaker.

With the microphone at the bottom speaker the right channel read 7 dB louder (-20.4 against -27.6 dBFS; room -85.7).

Rejected: An earlier 2 dB lean, taken while the microphone was not yet placed.

2026-11-11

Where the community's report and our measurement disagree, both are shown side by side; where we know nothing, the report is shown outlined, dated, as reported.

A disagreement is the most telling part of the comparison - the sensors one may be of our own making.

Rejected: Hiding a report behind our measurement; filling unknowns as if measured.

2026-11-11

Telephony is checked in three modes: automatic now (registration; a small download over mobile data), half-manual (the phone calls the author's other phone, the author confirms through the inbox), and fully automatic later (a two-phone stand, or a number that answers with a tone). The number to call lives in a private file on the lab machine, never in a repository.

The author allowed data and calls to his other phone, and asked that the checks become part of the test suite so a stand can run them unattended.

Rejected: Calls by hand without a check; keeping the number in the device manifest.

2026-11-11

No more LPASS or DSP-vote code for deep sleep now. The audio DSP's own qcom_stats counter stays a separate, smaller question (not known yet whether its firmware counts). The next try is the prepared cluster-parameters dtb (sleep-cluster-params) judged on a cycle, now possible because the wake is solved; after that the sleep set / the UARTs' CX votes.

A cycle with the audio DSP stopped, and one with adsp, cdsp and modem all stopped, still counted cxsd 0, aosd 0, ddr 0; the PSCI cluster state S2 was entered in the cycle.

Rejected: Stopping the remoteproc for good (sound and calls need it); more macro-clock work (no effect measured twice); treating adsp count 0 as the cause (the counter may simply not be filled by this firmware: not known yet); a third DSP try (the logs show the DSP is not the cause).

2026-11-17

sleep-cluster-params waits on a deeper decision; no more cycles on this dtb until a candidate (SH0 owner, qcom_aoss knobs, XO/VRM, USB, display RSC) is chosen

8 cycles with ftrace: cluster S2 used, CX/MX 0, sleep set clean except SH0 x=1 y=3, counters 0

Rejected: More cycles on the same dtb: they repeat the same zeros

2026-11-17

Deep sleep on surya is made on mainline s2idle and taken to the SoC's floor step by step, each step measured by the SoC's own sleep counters (qcom_stats: CX collapse, AOSS sleep) across a real suspend: first a measured sleep on today's kernel, then the cluster sleep parameters from surya's own firmware tables, then whatever holds the audio DSP awake, then the FastRPC helpers stopped across suspend so the sensors come back; waking for calls and messages follows on that floor, by the modem's IPCRTR wakeup with ModemManager's quick suspend/resume, as postmarketOS does on the OnePlus 6. The check soc-sleeps says it after every boot: unknown until the phone has slept, broken if it slept and the SoC stayed up, works once the SoC reached its floor.

Every step is small, falls back by itself (one sleep woken by the clock; a test kernel tried once) and is settled by a number the SoC counts itself, so progress is certain rather than claimed - nobody has published a measured floor for SM7150 on mainline, and the postmarketOS page that calls suspend working has no measurement behind it. The first step settles the biggest unknown: whether this SoC reaches its floor at all on mainline, before effort goes into waking it. Two causes are already in sight and both are cheap to try: the device tree asks the firmware for SC7180's cluster parameters (0x41001244, 0x4100b244) where surya's own tables have 0x41002244 and 0x4100c244, and the deepest was never entered once; and the audio DSP has never slept this boot. What it changes - a device tree fix, a vote released, a hook - goes upstream to the SM7150 series, pmaports and ModemManager, for every SM7150 phone. Reckoned: the measured sleep 2-3 agent-hours with its devlab verb; the cluster parameters 2; the audio DSP 4-8; the helpers 2-4; waking for calls 6 and a SIM card.

Rejected: Waking for calls first on today's kernel (postmarketOS's OnePlus 6 recipe as it is): no SIM card in the lab to prove it, it says nothing of whether the SoC sleeps - a phone that rings but drains in a day is not deep sleep - and it is still reported broken on OnePlus 6/6T and Pixel 3a; it is the last step here, not the first. Android's kernel through Halium (Ubuntu Touch runs on surya): deep sleep works there, but on the vendor's 4.14 kernel and Android's blobs, with nothing upstream and the mainline conveyor abandoned; kept only as observed behaviour - its standby current is the number to match. Runtime idle without suspend (the screen off, userspace running, the SoC left to reach CX collapse in idle): nobody has reached the floor that way on Qualcomm mainline, userspace timers keep waking the CPUs, and it needs every vote released that s2idle needs; the counters measure runtime idle too, so nothing of it is lost. A power manager of our own, as Crust on the PinePhone: Qualcomm's always-on subsystem runs signed firmware and the modem is inside the SoC with no ring line, so it cannot be done. Guessing at the cluster parameters or the audio DSP without a measured sleep first: a change could not be told to help without the counters across a suspend.

2026-11-17

Before any further suspend: (1) set the RTC (hwclock -w -u); (2) load a qcom_wdt built from the kernel's own source with one change, keep_armed_in_suspend=1, so an armed watchdog is NOT stopped in late suspend; (3) arm it with a timeout longer than the sleep (sleep + 30 s at least) by BusyBox watchdog and kill that process hard, so nobody pets it: it bites if the phone does not come back, and a stuck phone resets itself, boots the stock kernel and is reachable again; the script stops it by the magic close the moment rtcwake returns; (4) the log: a marker to /dev/kmsg before the fuse and the ramoops console (read from /sys/fs/pstore by sleep/way-back.sh collect) show what the last seconds were. Done as sleep/way-back.sh (verbs check, rtc, load, fuse, defuse, collect, cycle; no verb prints usage; cycle refuses unless the way back is in place) and sleep/build-wdt.sh. The way back is proven by 'fuse' on the idle phone (nothing suspends) before the one measured cycle; if the phone does not come back from that by itself, no suspend is tried and the author is told.

The first timed s2idle hung with no log and no USB return and needed the author's hands. The stock watchdog is stopped by the driver in late suspend, so it could not have rescued that hang (it ends only a hang before the late phase); the patched module is the only way found that needs no kernel rebuild, no reboot to test and no hands, and a reboot or rmmod undoes it. A bite is a hardware reset and does not depend on USB, the RTC alarm or a CPU that is alive.

Rejected: Stock watchdog alone: stopped in late suspend, covers only a hang before it. A timed reboot (rtcwake -m off/disk or a systemd timer): needs the RTC alarm or timers to fire out of the very state being tested, and a power-off wake is the bootloader's business on this phone. Keeping USB awake (devlab-usb-awake): it does not return a phone whose CPUs are stuck in s2idle, and the first hang showed no USB at all. Only a log that survives (pstore): it shows what happened but gives no way back, the author would still hold the power key. A rebuilt kernel with the patch built in: a long build and a boot-counted try for what a module loaded at run time does; kept as the upstream form (the parameter is a small patch for mainline) once the cycle is measured. Serial console: no serial pins open on surya.

2026-11-17

Read the entry before subtracting anything more. Two phone items, both read-only on the kernel (tracefs, procfs, debugfs; one 15 s cycle via way-back.sh cycle 15 bt-on with the watchdog armed): (1) floor-entry-trace: the rpmh sleep-set writes of the last CPU, the last CPU's idle state, per-CPU cpuidle and cluster genpd deltas, the interrupt delta, wakeup_sources, and every qcom_stats node before and after; (2) floor-irq-quiet: if the interrupts are not quiet, name the top sources and silence them one at a time (the pattern that fixed the same symptom on the Odin 2). Counters are treated as valid; SH0 is treated as one unexplained entry, not the blocker, and its owner-hunt (floor-sh0-owner, floor-sh0-qup-tags) pauses until the trace says whether the flush is what the AOP sees. A build item makes the interrupt check a suite test. Standby current stays the arbiter of last resort for counter validity.

The counter files exist because their names were read from the RAM, ddr_stats passed its key and moves; the awake icc read that pointed at SH0 is not the state at the flush (USB's 240000 is dropped by dwc3_qcom_suspend, the large peaks are tag 3); and every subtraction so far (DSPs, WLAN, USB, uart8) changed nothing while the three facts that decide whether the SoC can sleep at all - flush, last-CPU state, wake rate - were never read. The closest measured sibling (Odin 2) was held by an IRQ storm through a suspend that reported success. Reading is cheaper and safer than another one-shot dtb.

Rejected: More owner-hunting for SH0 by tag or by unbinding drivers (three tries, no effect, and a BT-blocked cycle resets the phone); the debug late-suspend kernel first (a build, when tracefs gives the same facts without one); calling the counters broken (their names and ddr rows read fine); porting downstream lpm-levels or smp2p sleepstate (already rejected, no new evidence); the rpmh timeout debug series with cmd_db name lookup (unmerged, useful later to name holders once something is held); dwc3 skip-phy-init quirk (host-mode PHY refcount on the Odin 2; surya is a gadget and the UDC-unbound cycle changed nothing).

2026-11-17

Chosen vector: measured subtraction on the existing s2idle, ranked by evidence. Order: (1) floor-read-holders (read only: cmdline, clk, regulator, icc, genpd, cpuidle); (2) floor-dsps-never-started (module_blacklist=qcom_q6v5_pas); (3) floor-no-ignore-unused if the cmdline has it; then one subtraction per cycle: WLAN, UDC, the SH0 owner, aoss knobs; a late-suspend dump kernel only if still open. Each is one change judged by way-back.sh cycle 15 bt-on and the soc-sleeps check (the failing test: it fails after a suspend with cxsd and aosd 0, and passes only at the floor). health-soc-sleeps-ddr widens the check to ddr and the rung. The decisions adsp-is-not-the-floor and cluster-params-are-not-the-floor stand for what they measured, but adsp-is-not-the-floor rested on stopped DSPs, not never-started ones; floor-dsps-never-started settles that.

Others reach the floor on mainline s2idle only by removing holders one by one (X1E, QCS8550) or fail on named clock votes (sm8250); surya's cluster state equals downstream's and apps_rsc equals sc7180's, so no system mode is missing. The counters are valid but name no client on this layout, so subtraction is the only instrument; the biggest unknowns (kernel cmdline, clk holders, latched DSP votes) are read-only or one cmdline away.

Rejected: Another cluster-state value (state taken equals downstream/sm8150; 8 cycles repeat zeros); PSCI SYSTEM_SUSPEND / s2ram (firmware does not offer it, kernel series NACKed); smp2p sleepstate port (not in mainline for this SoC, weakest evidence, large work); more LPASS macro clock work (no effect twice); treating the counters as broken before standby current says so (kept as hypothesis 6 / sleep-standby-current); a downstream-style lpm-levels port (the flush mainline does matches).

2026-11-17

surya's microphones are made to work as the analog mics they are: AMIC1 (bottom) and AMIC3 (top) on the WCD9375's ADC1 and ADC2 (ADC2 MUX at INP3), over the TX SoundWire bus (capture on <&swr2 1>, ADC2 on its own master port 3 by qcom,tx-port-mapping <2 3 4 5>), the TX macro's decimators and the DSP's TX_CODEC_DMA_TX_3 - the path pulpoff/linux-surya and sm7150-mainline PR 60 use, and the one bring-up proved on 2026-11-17 (run 20261117-044744: mic-hears-speaker and mic-top-hears-speaker pass on the kept kernel 7.1.0-sm7150-mic+). What is left, in order: capture through the sound server by a UCM profile (mic-ucm-capture, first: the biggest unknown left for anyone using the phone, since every check so far sets the mixer by hand), the microphones held across boots and out of the known gaps (mic-held), the fixes upstream by joining PR 60 (mic-upstream), the DMIC experiment kept out (mic-dmic-dropped), and the call uplink with the calls feature (calls-audio-q6voice).

Measured, not inferred: both built-in mics hear a quiet tone 45-67 dB above their noise on this phone. An independent mainline tree on the same phone records both mics and carries calls this way and names the DMIC pins unconnected; the DMIC reading came from Qualcomm's reference board. What is left is configuration and carrying it upstream, each step proven by a check on the phone; no reverse engineering is needed. Research: microphones-are-analog, mic-zeros-meant-no-input, bolero-v1-capture-family (microphones-are-analog and bolero-v1-capture-family stay in linux-phone-oco/docs).

Rejected: DMICs through the TX decimators with the VA block's clocks (the vendor's va-without-decimation model, bring-up's lead until 05:00 on 2026-11-17): surya has no digital mics - the routes are the QRD board's and the pins are unconnected; the model stays recorded (bolero-v1-capture-family) for siblings that have DMICs. The VA macro's own path (VA_CODEC_DMA_TX_0): this ADSP rejects the port (0xb021, error 3), nobody streams it on SM6150/SM7150, and there is nothing for it to record. pulpoff/linux-surya as surya's kernel: it works, but it is 7.2.15 (end of life), squashed into one commit and packaged for Debian, while the conveyor builds tested branches of linux-phone-oco/linux toward sm7150-mainline - we take its findings with credit, not its tree. Driving LPASS codec DMA from Linux without the ADSP (lpass-cpu, as ADSP-less Chromebooks do): unnecessary and a large, risky driver. A surya capture series of our own for upstream: davinci's PR 60 already carries three of the four fixes; a parallel series would split the review.

2026-11-17

Coordinator's choice (a) taken (supersedes 2026-11-17-r3-waits-on-the-bluetooth-choice). The abort is on 4 zero-sleep cycles in a row, not 2: 24 of r2's 47 cycles slept 0 s with Bluetooth healthy, so 2 would abort on noise. The abort writes STOPPED 'aborted, partial'; samples before it with charger_online 0 still count. No cycle starts after a Bluetooth failure, so the 30 s fuse cannot meet the retry loop; only the first stalled cycle can still reset the phone. (c) is backlog sleep-irq157-quiet, after r3.

Same evidence as the research; the zero-sleep rate is r2's cycles.log.

Rejected: 2 zero-sleep cycles (noise); BT blocked (hung hard).

2026-11-17

Option (a) of 2026-11-17-r3-waits-on-the-bluetooth-choice, taken on the coordinator's order to make r3 safe: standby-run.sh counts hci hardware error / irq 157 nobody cared / freeze refused in dmesg and, once the count rises, or after 4 cycles in a row that slept 0 s, writes STOPPED and ends without another cycle (no fuse can fire then); a run without DONE and a full measure phase is never scored. r1 marked INVALID, r2 UNSCORED on the phone. The first cycle that stalls can still reset the phone; then the run is unscored and the boot journal says so.

Bluetooth blocked hangs the phone hard (research 2026-11-17-surya-s2idle-bt-blocked-hang) and irq 157 quieting is untried; (a) changes only the run and keeps the phone as stock.

Rejected: (b) BT blocked: hung hard before. (c) quieting irq 157 first: a driver/dt change no research decided.

2026-11-17

r2 is closed unscored. r3 (a run that needs the author to unplug again) is not armed yet: the run must survive Bluetooth's failure, and that has three ways, a turning point sent to the surya coordinator: (a) bt-on as now, but the loop stops itself and writes BAD when a cycle sleeps 0 s twice in a row or hci0 reports a hardware error, so it ends with an honest 'not measured' instead of a reset; (b) Bluetooth rfkill-blocked for the run (it hung the phone hard in cycle 15 with BT blocked, research 2026-11-17-surya-s2idle-bt-blocked-hang, so only with the watchdog fuse and the UART wake irq handled); (c) the QCA UART irq 157 quieted first (research 2026-11-17-qca-uart-wake-across-suspend: the serial's power/wakeup switch).

The cause is in the run's own design, not the phone: a stalled cycle past the 30 s fuse resets it, so any r3 on the same script meets the same end once BT fails, and each try costs the author an unplugging.

Rejected: Re-arm r3 unchanged: the same stall resets it again and costs the author's hands. A longer fuse: the qcom watchdog counts 32 s at most.

2026-11-17

r4 repeats r3 (Bluetooth on, 75 min, waits for unplug) with two changes: (1) a once-tried boot with noirqdebug on the cmdline (boot-counted, falls back by itself) so the kernel does not disable IRQ 157 after 'nobody cared' and BT does not die at ~65 min; (2) on any Bluetooth failure r4 ends scored as partial AND stops bluetooth.service / blocks hci0 with the phone awake and plugged-in-agnostic so the QCA retry loop (which preceded a reset) is not left running. Needs the author to unplug again. Lane coordinator to confirm (1) is a kernel-cmdline change.

r3 ran 63 min clean and died exactly when 'irq 157: nobody cared' disabled the Bluetooth UART line (research 2026-11-17-r3-partial-and-the-reset-after); the retry loop that followed ended in a reset.

Rejected: Bluetooth blocked or unbound: hangs s2idle hard (earlier research). Treating the 63-min partial as the score: below the 75 min asked, and 31 mA median is not Android-comparable. Assuming the fuse caused the reset: the journal has no sign of it.

2026-11-17

lab/build-hexagonrpcd-sns.sh builds the patched daemon on the lab; lab/sensors-install.sh installs it on the phone. device.toml keeps sensorspd masked (a fresh flash has no patched daemon: the stock one would crash-loop the audio DSP); the health gap 'sensors' is removed because the suite now passes it.

Three boots with 0 crashes (research 2026-11-17-sensors-lasting-install-three-boots).

Rejected: A binary committed to the repo: 0.7 MB of build output. Unmasking in device.toml: breaks a fresh flash. A package: no pmaports route yet (sensors-upstream).

2026-11-17

The sensors on surya come through the stack postmarketOS already ships - hexagonrpcd's sensors helper, libssc and iio-sensor-proxy - with the firmware's own pre-parsed registry kept current so the audio DSP never needs to write it: the 46 sensor configs given Android's fixed mtime (1230768000) so they match the registry's record, sensorspd alone unmasked (rootpd stays masked). First a bounded probe on the kept kernel; then it made lasting in the device manifest and offered upstream (firmware-xiaomi-surya, pmaports, a word on hexagonrpc #19/#29); then the helper across suspend, tied to deep sleep's sleep-fastrpc-helpers; then proximity blanking the screen in a call. If the probe still sees the DSP write, the fallback is write support in hexagonrpcd (sensors-registry-writes). Proven by the suite: motion-and-light and proximity-reads, with no-processor-crashes and the microphone and call checks unchanged in the same boot.

The crash is explained by two conditions the trials of 2026-11-09 never met together - every config looks changed to the DSP (real mtimes against the registry's 1230768000) and the version marker is unreachable - and the first of them is settled with no code: a touch of 46 files and one service unmasked, undone by masking it again. The registry already holds the light and proximity sensor, so neither writes nor the panel property are needed if nothing is re-parsed. It disturbs the DSP that carries the microphones and calls only for the length of a probe whose fallback is the mask that holds today, and every step is proven by the same boot's audio checks. What it yields - configs at the vendor mtime - is a packaging fix every SM7150 phone with these firmware packages can take (davinci's loop looks the same), where write support is days of work on a daemon whose maintainers have not settled where writes go. Reckoned: the probe 1-2 agent-hours; lasting 1-2; across suspend 2-4; proximity in calls 3-6; the fallback, if needed, 8-16. Research: sensors-registry-rebuild, sensors-hardware-surya, sensors-family-state, sensors-across-suspend.

Rejected: Write support in hexagonrpcd first (#27, a -S state dir, the 700-line #29 patch): days, our own build of a daemon upstream has not decided on, and on X1E it stopped the crash yet found no sensors; kept as the fallback, not the first step. Serving the phone's real persist registry (!8203, the 2026-11-09 real trial): without the marker served it changed nothing here, and serving it needs the same hexagonrpcd change; closed upstream. Linux drivers for the chips on the sensor core's buses: the DSP owns those buses and would fight for them (X1E), stk3a5x has no mainline driver, and it costs power. Android's sensor stack through Halium: the vendor's 4.14 kernel, nothing upstream, the mainline work abandoned. Leaving the sensors masked and faking proximity with the touchscreen: no light, no rotation, no real proximity - the author ranked the sensor hub second.

2026-11-17

way-back.sh cycle SLEEP bt-on: unblock Bluetooth, write 'disabled' to /sys/bus/platform/devices/88c000.serial/power/wakeup before suspend, put the old value back after. Bluetooth cannot wake the phone for now (wanted later only for paired devices, with the sleep-wakes-for-calls work).

The wake that ended s2idle was the serial's dedicated RX wake irq 158, armed because that device's wakeup is on; the sysfs switch is the mainline way, reversible, needs no module build or reboot, and keeps hci0 and its firmware loaded (resume needs no re-setup). Result: 3 cycles woke by the RTC alarm, Bluetooth up after.

Rejected: rfkill block bluetooth before suspend (the earlier way: the phone hung at suspend entry once, and Bluetooth is wanted up); unbinding hci_uart/btqca before suspend (loses hci0, reloads firmware at every resume, and a failed rebind could leave the UART dead); deleting the second interrupt in the device tree (a dtb rebuild and a reboot for what one sysfs write does, and it removes the paired-device wake for good); persisting the off state in a udev rule now (not until the sleep path is proven)

2026-11-17

Chosen vector: subtract the SH0 sleep vote at its source, in the device tree. Step 1 (read only): at late suspend list which interconnect paths through qns_llcc/SH0 carry a SLEEP-bucket vote. Step 2: one-shot dtb with uart8's (debug UART) interconnect tags set ACTIVE_ONLY, console moved or the UART unbound, then cycle 15 bt-on: judged by the sleep-set flush (SH0 gone) and soc-sleeps. Step 3, only if SH0 stays: the other QUP/crypto TAG_ALWAYS nodes one at a time. If SH0 goes to zero and the counters still read 0, SH0 is cleared as a holder and the next suspects are hypotheses 2/3/6 (clocks, UFS/GDSCs, counter validity; sleep-standby-current). QMP no-ack: read-only discriminators, no change to the AOP path.

SH0 is the keepalive BCM of LLCC on sdm845, sm8150, sc7180 and sm7150 alike (bcm-voter forces it only in AMC/WAKE), so the sleep-set x=1,y=3 is a consumer's TAG_ALWAYS vote through qns_llcc, visible and removable in the device tree; uart8 (debug UART, avg 1 peak 1 across suspend) is the recorded candidate. It is the only non-zero sleep entry and one dtb away, while the QMP no-ack has no cheap explanation and serves only a low-ranked hypothesis. Whether SH0 blocks aosd is not known yet; the test settles it by the counters.

Rejected: Fixing QMP first (the knobs only test hypothesis 5, unlikely; wiring equals sm8150, nothing points at the cause; kept as a read-only item). A late-suspend dump kernel first (a build and install for what one dtb answers; kept waiting). Zeroing SH0 by a driver patch or keepalive=false (it is by-design on all siblings and hides the consumer; the DT tag is the honest change and the one that could go upstream as a correction). Treating SH0 as a firmware latch (the sleep bucket is built only from consumer tags). Reading the Aspire 1 sleep set as proof SH0 is harmless (not measured by anyone).

2026-11-17

The floor is judged by battery-only average current across a suspended cycle (charge_counter delta over the time, screen off, modem on), the line to match being 9 mA until Android on surya is measured. Next phone steps in order, each read-only or one change per cycle: (1) read every power-domain idle_states row and regulator_summary users before and after one cycle; (2) allow USB runtime PM (power/control auto on the PHY and controller) and read again; (3) the standby-current cycle itself. The AOP view is not chased further: the flush is sound and has no Linux-side reader.

The entry is in order (flush, deepest cluster state, quiet IRQs). The closest peer (pmaports#4846) shows counters can read poorly while holders are fixed one by one with no current change, and that regulators and USB, not the AOP, were what moved the draw; a measured 9 mA Droidian figure on the same generation gives a line. Only current is independent of the doubts about the counters.

Rejected: Reading the AOP's log or message RAM beyond the stats (no mainline reader; downstream-only); more tracing of the flush (done: floor-entry-trace); S2RAM (rejected by floor-research-path); measuring Android by flashing surya now (changes the phone, not research's, and the miatoll figure gives a line meanwhile); treating aosd/cxsd counts as the only pass (peers show they can stay 0 while the draw is dominated by rails)

2026-11-17

Entered as a test with a witness step (the author unplugs USB), threshold 15 mA, scored as mean current from the charge_counter delta over the window (current_now only a cross-check), at least 60 min measured after a 10 min settle, Wi-Fi on, Bluetooth on and off as separate runs, screen off, samples every 30-60 s, charging samples discarded, invalid runs kept as invalid. The one-off run now prepared is the first such run (Bluetooth on).

Made repeatable so every kernel change is scored the same way; the charge counter avoids the wake-sample bias; see research standby-drain-as-a-repeatable-test.

Rejected: A single 10 minute measurement (counter too coarse); scoring by battery percentage (least trustworthy); a name 'suitcase test' as a standard (none exists); Android's number as a gate now (not known yet).

2026-11-17

A test kernel that proves a part is built from pushed branches of linux-phone-oco/linux (a test branch merging the fix branches), never from a hand-edited tree. Hand-edited trees stay for one-off experiments (switches, traces), their changes kept as patches in surya-audio/patches; a finding becomes a commit before it is called proven.

On 2026-11-17 the WCD device tree on feat/surya-wcd937x-mic-headphone turned out never to have been the tree proven on the phone - wrong SoundWire controller addresses, a vote the DSP rejects, the reset's polarity - because the proven tree in surya-audio/kernel-rc3/src-wcd was edited by hand and never committed. The branch kernel built from PRs 3-5 then booted healthy with the codec.

Rejected: Keeping the working tree that proved something as the reference: nothing reads it, it drifts from the branches, and what is sent upstream is not what was tested.

2026-11-17

surya-lab gives up its own conveyor scripts, devlab now doing their work for any phone: lib/phone.sh (devlab phone: the same script-on-stdin way, the USB address then the learned Wi-Fi one, now from device.toml, and held for each change), tests/run.sh with tests/automatic/checks.sh (the phone runs its own suite after every boot: lab-tools health/suite and tests/health here), tests/to-docs.sh (devlab gather, through tad - the Python dc.py it called is gone), flash/flash-dtb.sh (pointed at a flash.sh already gone; devlab flash --dtb). ui/switch.sh now reaches the phone through devlab.

One way to reach and test a phone, held and measured, instead of two that drift (device-template dt-surya-from-template). The reasons each script carried were read first: the full kernel log from the journal and BusyBox-safe awk live on in lab-tools health/suite/lib.sh; the checks not yet carried are on lab-tools backlog health-carry-old-checks.

Rejected: Keeping the scripts as a fallback (a second way nobody runs drifts, as flash-dtb.sh had); moving them into the template (devlab already does each, for any phone).

2026-11-17

Keep the patch as research material only; the kept kernel and the dts stay as they are. Next measure the DSP side (what the ADSP firmware waits for: sensors PD, call audio, a vote from another subsystem) before touching more LPASS code.

Measured on the phone: cycle 15 bt-on on the try kernel gave adsp 0, cxsd 0, aosd 0 as on the kept one; sound checks still pass (35/0).

Rejected: Landing it into the kept kernel as a fix: no measured effect and not yet explained why clk_summary still shows count 3. Switching rx/tx to the full PM clock framework conversion now: bigger change, same unproven effect.

2026-11-17

The way, in this order, each step one phone item measured on way-back.sh cycles with the watchdog armed and the serial's wakeup switch left ON (production state): (1) bt-trace-cycles: 20 cycles of 15 s and 3 of 120 s with dyndbg on hci_qca and trace_geni_serial_irq, to read whether the irq 157 storm comes before or after the controller crash; (2) bt-sleep-cts-pulldown: a one-shot dtb with CTS pull-down in qup-uart3-sleep like sc7180-trogdor, the same cycles; (3) if (1) or (2) still lose the controller: bt-unbind-hook, a sleep hook that unbinds only 88c000.serial:0 from hci_uart_qca before suspend and binds it after (SteamOS 2845's workaround), the same cycles plus a BT audio reconnect; (4) bt-suspend-gate, always: sxmo's autosleep does not call rtcwake while hci0 is not UP or an rfkill is in D state, so the r4 wedge cannot recur whatever the controller does. Proof: tests/health/base/bt-suspend.sh passes after the cycles (no storm, no crash lines, hci0 up, no stuck rfkill, wakeup on).

Surya's device tree already equals the one mainline phone-class wiring that sleeps (sc7180-trogdor) except CTS bias, so a device-tree rewrite or a driver patch would be a guess; the failures are a 200 ms sleep wait that times out and a level irq that storms once the port is suspended, whose order nothing has measured; the r4 wedge was sxmo's suspend loop on a controller in SSR, which a gate removes independently; the only user-space remedies others report are power off or a serdev unbind.

Rejected: rfkill block or hci down before sleep: BT blocked hung suspend entry hard twice and its mutex wedged r4; noirqdebug or disabling irq 157: hides the storm, r4 showed it did not stop it; keeping the serial's wakeup off as the product: it is the test switch, RX wake is the design; BT permanently off in standby (bluetoothctl power off): drops BT peripherals, kept only as the last fallback; patching hci_qca timeouts first: upstream-shaped but needs the cause measured, queued after step 1.

2026-11-18