What’s new

Now a press on a failed walk opens a small sheet with the whole message and one key the shop PC chose: bring the file in from the X5 again, ask the shop PC again, or walk it again.

The first case is new: a file copied off the X5 while it was still recording has no index, so the engine cannot read it and asking again can never help. The shop PC now says exactly that, and the key opens Walk so the full recording can be brought in from the camera’s card.

Now the copy is final only when the re-read head says so — a sized mdat with the index after it — else it keeps waiting for the camera to close the file (up to its 90 s, then the road after Stop copies it whole). The original is still on his card; the X5 closed it after the copy had already left.

A TEST build, not the update notice: builds/test/b11.apk.

And: the shop PC card said only "1 in line" while the box sat resting after its memory ran out. The box now reports its rest and when it ends in its heartbeat, and the card says "resting after its memory ran out — starts again 8:01 PM", or "starting it now".

A person's own Claude still reads their record through the connector, on their own plan — search, a day with its photographs, a 360 walk frame by frame. tradesman_ask now says so instead of answering. The camera form loses its Scan key; the Wi-Fi name and password are typed.

The code is kept behind one switch (TRADESMAN_APP_MODEL=on, and NEXT_PUBLIC_TRADESMAN_APP_MODEL=on for the Scan key) that turns it back on for everyone at once. Batches already out are still collected; nothing new is sent.

The front: each job is one row with a round picture — its newest walk — and one line under its name (when it was worked, how many walks), then its newest photos as small circles ending in "+N". The job you are standing at leaves the list for its own spot at the top, "You're here", with a bigger ball, a HERE tag and how many walks it has; while its tour is on the way it wears the same four step dots the Walk page shows (the X5, the phone, the shop PC, the tour) and a ring of how far along it is. Held stops show as one amber line. The shop PC is one card at the top when it is busy. New job and Unfiled share the last row.

A job's page now opens on one big round picture of its newest tour, the walk count on it and a "Walk the tour" key under it, then the job's name large and one line. The address, Directions, who is on it and its docs are chips under the name. Each day is one row: its walk's ball (greyed with a ring while the tour is on the way, an empty glass ball on a day with no walk), the date and the walks' times, the step dots while it builds, one line, the day's photos as circles, and Claude at the right.

The dock is one big red key for a 360 walk, with Photo beside it and Upload (on the front) or Note (on a job's page). The word under the red key — "Walk Redland", "Walk it again" — names where the walk goes; pressing that word opens every way to capture and the job and day picker, so nothing the old key did is gone.

Not done: nothing here has met his phone. The front's here-spot shows the step dots only for walks on the shop PC (a walk on his own computer has no dots yet). The tour viewer's mock is another build.

What stays is one upload size limit, the same for every account: a photo 4.4 MB, a clip 300 MB, a PDF 25 MB, a 360 walk 6 GB. The shop PC builds walks in the order it always did, nobody first.

The engine, shop-tour, is public the same night as a clean single-commit export; its old history stays private.

The landing promised a floor plan, a dollhouse and a tour. The plan and the dollhouse have been off the glass since Oct 28 until they are good enough, so the sentence now says what you get today: a tour of the whole job.

The demo tour asked storage for a photo list it does not have on every open, and that showed as an error in the browser on the front page. A tour with no photos pinned to it now answers that question itself — nothing goes out, nothing fails.

The shop PC page named the engine by our private build name and had no way back. It now says in plain words what that computer does — builds every 360 tour, faces, plates and printed names blurred first — with a way home.

Four were the app. A job with days and no job doc yet had no way to keep its first doc — the day's + that held it left on 10-30 and the Docs section draws nothing until there is one — so the job's ⋯ says Add a job doc again until the first is kept. On the front, holding a photo to pick it slid the whole day up the page by the job list's height, because the list stepped aside; now it stays where it was, dimmed and out of reach, while he picks. A shared day's groups sat 6 px in from the loose photos beside them. And the words Walked twice on an opened day were a 20 px press beside the 96 px ball — words now; the ball and the time pills are the presses.

The nightly sweep shares the night fairly: the owner's owed photos first, every one, then at most 60 of each other account's. The X5 screen reader used to call Claude for anyone who asked; it needs a sign-in now.

Uploads know their size for everyone but the owner: a phone clip up to 300 MB, a 360 walk up to 6 GB (the one-piece link, the multipart parts and the finished object are each checked; an object over the cap is taken back). Photos (4.4 MB) and PDFs (25 MB) were capped for everyone already. Nothing the owner does changes.

Now each asks the shop PC's key or his own session, and a walk is read only by the people on its job. The shop PC signs its calls and never follows a redirect with its key. Nothing changes on his phone. What was left as a judgement call is written down in docs/release/SECURITY_REVIEW.md.

Now it sends the way the relay does: on validated internet (the shop Wi-Fi beside the camera's, or real cellular), then the cellular handle, then the default route, trying again with a pause between. When it cannot, the Walk page writes down why ("upload off: …") in its ledger row, and a row lands the moment the first part is up.

Build 9 threw the whole upload away at Stop because the X5 writes the file's first bytes last. Build 10 sends part 1 again with the real head and keeps everything else that already went up.

This is a TEST build, not the update notice: builds/test/b10.apk. A fast 8K walk writes about 15 MB a second, more than any phone uploads, so at Stop part of it is still going — the head start is the point.

Under it, each of your walks is its round picture with a ring for how far along it is, the time, and four dots: the X5, the phone, the shop PC and the tour. Done dots are dark, the one happening now is blue, the ones to come are grey. One short line says the rest: Copying 37%, In line, Building the tour 8 min, 2 stops need your eye (press it to review), or Tour ready with an Open key that opens the tour right there.

Recording is the clock, a red Recording, the stop key and one card saying how much of the walk is already saved to your phone. After Stop, a big green card says X5 can go off only when that is true: the file is whole on the phone or off the card. Until then an amber card says Keep the X5 on, with the copy percent. Then Record another.

Everything under it works as before: the copy still starts the moment you stop, the tail still writes down what it did, review and Import are the same. The long shop PC line is gone from this page; each walk's dots carry it, and only an off shop PC gets one small grey line.

Now every change in what the phone does with the camera file while he records is one ledger row (x5.cardTail) with its reason, and a walk saved with no word from it at all is one too. The next walk tells us which side failed.

While a tour loads, the glass shows the tour's own picture (the small cut the Record already holds paints at once, a sharper one over it) under "Loading the tour…" — never black. A tour that will not load shows its picture dimmed behind the words, with Try again first and Open in your browser beside it.

Smaller things on the daily path: the tour's header says "22 spots · 2 floors" and stands whole (on a small phone Share is its mark alone); an opened day walked twice says "Walked twice", never "2 360 walks"; a day's line says "1 photo · 1 walk"; on the Walk page "on" and the day wrap together, and "Saved to <job>" comes before the copy's progress.

How it works still described the September app: a Jobs tab, Note, Voice and Link on the shutter, a Tools key and 3D drawings that are no longer on the glass. It is rewritten for the app as it is — the 360 walk first, then photos, your jobs as days with their tours, sharing a tour, Claude, your crew, and that the record is yours — and it names only keys you can see.

The front door had no way to How it works or Privacy; both now sit on the engine line, so the page still fits one screen. Sign in and sign up spoke of photos and notes only; they now say what the app makes — the tour — and keep every photo.

A shared tour of a walk with no name read "360 tour" over "Vitronic · 360 tour": the job is its title now, said once. Its foot held a link inside the phone's bottom strip; the mark at the top is the way to Tradesman. The tour frames lost a duplicate fullscreen attribute every browser warned about, and Privacy no longer names a picture-of-tasks reader that was taken out with the tasks.

A tap on the small map opens the same map over the whole glass, every stop numbered, the ones he can walk to from here brighter, the view cone where he looks; a tap on a stop glides there. A Play key walks the tour by itself, stop by stop, turning to face the way it goes; any touch stops it.

Found on the way: a page or a tour.json re-served into a live tour's folder was not reaching the app for an hour or more, because the storage kept the old copy under its bare name. The app now asks for the page with a mark that changes every minute, and the viewer's own reads of tour.json carry the same mark, so a re-served tour lands within a minute.

Never a gate: no sign-in, no internet, a part the storage refuses, and the upload ends quietly (the multipart aborted) while the road after Stop copies and sends the file as before. The Walk page says it as it goes: "412 MB of it is already on the phone · 260 MB sent", "Sending the walk · 3,710 of 3,930 MB — the X5 can go off", "The whole walk is sent — the X5 can go off". Unproven on a real X5 until the next walk.

Now the engine takes the walk the moment its file is on the box. The watchable 360 and the frame shelf run after the tour, on their own thread, once no tour is queued or building. And the file comes down over six connections at once, one stream when the storage refuses ranges. The walk’s row says the shop PC’s own step throughout.

Three fixes. The copier (the app’s build 6) throws a refused resume away and copies the file again from the start, and the background copier checks the copy against the card’s own listed size before it files anything. The server checks the uploaded object’s size against the card’s and refuses a short one in words. And a walk whose camera file failed on the shop PC is no longer "in the Record" on the card sheet: its file is offered again, and the record takes it again.

Now every stop of an .insv walk is levelled by the camera’s own gyroscope and accelerometer: gravity read over a stride either side of the stop, each sample turned by the gyroscope into the stop’s own instant, through the sensor’s fixed mounting in the camera. Measured against the vertical edges on 25 stops of three walks (median 3 degrees apart) and proved on a stop he carried at 59 degrees, which came out level. A video with no sensor still levels itself from its pictures, vertical edges first and the skyline only where there is no vertical to vote with.

A stop the map could not place now takes its place from the walk’s own motion track, so the far side of the street is in the 11:34 tour (15 of 15 stops where 8 were). The rings step no longer refuses such a stop.

The people blur covered whole bodies and a lot of what the viewer wanted to see. By default people now stay in the picture as shot; faces, plates and printed names are blurred as before.

The per-day + is gone from the Record’s and a job’s day rows. The capture stack’s line, "Files to <job> · <day>", is a key: open, it lists his jobs nearest first — the one he stands at is marked and chosen by itself when nothing else is, so a photo on site never lands in Unfiled — the day an Upload lands on, and New job.

Said plainly: whether the X5 serves a file it is still writing is measured tonight on his phone, not before. If it refuses, the tail ends quietly and the copy after Stop runs as it did. Build 5 (1.4) carries it, as a test copy under its own address; the app everyone installs is unchanged until one real walk has gone through it.

Now the page hands the copy road the walks it shows waiting for the camera's file, and every card file the record matches to one of his streamed walks by when it began is brought in, the walk just saved first, then the ones on the page, then the newest. The phone's own memory of a walk matches by the file's name as well as its path. Connect means it, on any phone, after any reload.

Then, the same hour, his read of the first run: the copy's words sat at the foot of the page while the walk's own row still said press Connect, and the shop PC's line told him to press Connect with the X5 already connected. Now the copy and the send are said on the walk's own row with a bar, the walk after it says it is next, the Done lands on the row, and the line stops telling him to press a key he has pressed. Measured off the ledger: the 656 MB walk copied off the X5 in 23 seconds and took 148 seconds to send over cellular, because the camera holds the phone's Wi-Fi while it is connected. The send is the wait, and it is the next thing to take off his hands.

The landing's frame now takes the height left between the sentence and the foot — portrait on a phone, wide on a desktop — with everything still on one screen, and the page's own word over the viewer is gone. The Help pictures were refused by the page's policy twice over: the prelude that sends a tour's relative pictures to its storage folder was inserted before the page's first script, and the help markup comes before that script; and the shop PC never uploaded the guide/ pictures with a tour at all. The prelude now goes at the head of the page, the pictures ship with every tour, and the four live tours were re-served with both fixes.

The engine's viewer gained a Motion key on touch screens: the view turns with the phone the way a street view does. Off until pressed (iOS asks its permission inside the press), a drag still turns the view, no jump when it comes on, and "No sensor" when the phone has none. Every frame the app puts a tour in now hands the frame the motion sensors (gyroscope, accelerometer, magnetometer) beside fullscreen. Nothing here has met a real phone's sensors yet; the first turn of his Razr is the proof.

Said plainly for the record (CLAUDE.md, STOP IS THE LAST PRESS): the Android build 4 that copies and sends a walk in the background with the screen off is built and committed but not published — it goes out after one real run with his X5 — and whether Cloudflare R2 still refuses an upload was not measured tonight.

Now the copy of the walk just saved starts the moment the camera's last seconds have drained — no idle wait — and it goes before any older walk. The screen is held on from Stop to the last byte of the send, and asked for again whenever the page comes back. If the camera handed back no file name at Stop (it stopped on its own — a full card, a flat battery), the record's match by when the walk began still finds its file on the card.

If the X5 goes off or out of reach part way through, the walk is not failed: it waits, says so ("nothing is lost — the copy picks up by itself the next time the X5 is on and connected"), and is tried again on its own — in thirty seconds, at once when the page comes back to the glass, or whenever the camera is next connected here or on /x5. No press.

The words say what is happening and what he can do: "Saved. Copying the full-quality file off the X5 · 43% · about 2 min — keep the X5 on until this says done. You can put the phone away." The moment the file is off the card it says the X5 can go off, even while the upload runs over cellular; when it is in, "Done — the X5 can go off. The shop PC is building the tour." Not yet met on his Razr; the native foreground service that keeps the copy going with the app in the background is a separate build.

One line in lib/capture-model.ts carries it now, and tests/tour-model.spec.ts pins it: a queued walk stamped waitsFor reads "Waiting for the camera's full-quality file — open Walk with the X5 on and press Connect" on the Record, a job's page and the orb's toast, shop PC up or down. The walk itself needs the same press it needed before: Connect on the Walk page with the X5 on.

Opened, a day on a job’s page and on the Record now leads with ONE 96 px orb — the day’s newest walk in a thin halo ring, its count on the ball — and beside it the day’s walks as time pills, oldest first, the newest in ink; a press on a pill walks that one. Under the pills one line says where the tour stands and what goes with it (“Walk the tour › · 9 photos · 1 clip with it”), and the day’s grid follows. The small orb and the strip of squares step aside while the day is open (the grid is the photos) and come back when its line folds it.

Both pages draw the same block (DayRow.tsx OpenWalkOrb). The pills are 44 px — law 1 caught the first cut at 30. Pinned by tests/job-walks.spec.ts (a day walked twice) and tests/days-closed.spec.ts.

Now the line is the date and the street, and one soft line under the orb and the squares says what the day holds — “walked 2 times · 9 photos · 1 clip” — with anything still on its way beside it. The same block on the Record and on a job’s page.

The + on a day is a menu now: add photos, write a note onto that day, add a link, and on a job's page add a job doc — the four ways that used to live at the foot of the job. The address, Directions and who is on the job moved to the top of the page, and the people show on the front's rows and the Record's days too.

In the People sheet, 'How Sergio sees it' draws the job as that member sees it — nothing to rename, move or delete. The profile opens on his work: tours as orbs, jobs as rows, the crew as faces, then the photos.

Behind the glass: the full production build runs on the shop PC again and is the gate before every push — it catches what the nine failed deploys since October 14 died of. Vercel's deployment retention is a day for anything but production, a week for production.

While it waits the app says so in one sentence everywhere the walk shows — the Record's row, the Walk page, the shop PC's status line: the camera's full-quality file is still on the X5, open Walk with the X5 on and press Connect. The file then comes in by itself and the shop PC builds the tour from it.

The Walk page is simpler. The shop PC's own line is the first thing under the title — what it is building, the step, the minutes left, who is in line — with only the walks still on their way under it. The list of finished tours is gone from this page; a tour is the walk's orb on the Record and on its job. Where a walk files now has a day as well as a job: a recording or an import made today of Tuesday's walk goes on Tuesday.

The capture key now wears its destination over it, 'Vitronic · today', changing as you move through the app, so nothing goes in on faith. (Second deploy: the first build failed on Vercel.)

The stacked orbs and the chapters from earlier tonight are gone. The owner: "a walk should be a static thing for a day, but there can just be different times."

Opened, the day reads as chapters: each walk a wide card that opens its tour, with the photos taken during that walk under it. What was taken outside any walk comes last. The photos feed the walk; the walk is the frame.

The owner asked for it after a photo added at 8:05 PM went to the wrong day.

The capture key says where it files before the press: the job, and today. The adding toast says the day too.

The row opens the day's squares under it. Work with Claude is a small word at the row's end.

Make a 3D drawing, Make it 4D, a photo's 3D, a group's 3D and the Tools drawer are off the glass. The code stays, and each comes back when it passes. The landing page shows the tour alone.

Now the Walk page does the same as the camera screen. Once the walk is saved and sent, it copies the walk's own file off the card, and the shop PC rebuilds the tour from it.

Now a walk streamed through the app goes straight through the tour engine from its own stream, privacy check and all. When the camera's own file comes in later, the tour is rebuilt from it in full quality.

A failed walk now says the box's real reason on its line instead of a generic one.

Now the shop PC skips that old model whenever the tour engine is on (SHOPBOX_POINT_MODEL=on brings it back). That covers a streamed walk's live solver, its final pass, and an uploaded camera file's point cloud and splat training. The footage, the walk check and the tour are untouched.

The status page reads the shop PC's own heartbeat, so anything it is doing shows as Busy, with what it is. A walk streamed through the app waits for the camera's full-quality file, because the tour engine builds from that file. The status page now says so, separately from walks in line, along with the one thing that brings the file in: open the camera screen with the X5 on.

People in a walk are blurred by default and no stop is ever held for review any more, so a tour is never stuck waiting for his eye on a work zone. SHOP_TOUR_PEOPLE=remove on the engine brings back the old paint-out and the review for anyone who wants a stranger taken out of the picture rather than blurred.

Not yet proven on a live walk: the early tour, the blur and the dollhouse exposure and seam fixes have met tests and a stand-in engine, not a real X5 walk through the shop PC. The first walk after the box pulls this is the proof.

A press on the orb walks the day’s tour when there is one, else opens the day exactly as it always did; a press on a circle opens that photo or note in the viewer; the date opens a day that has a walk. The page also stopped trusting its rows: a walk with no clock, a photo with no time, a picture that is not a picture no longer take a whole page down — they stand in an undated block, or as a plain circle.

On a job's page the words Work with Claude now curve over the top of each day's orb, a tap that opens the Claude sheet about that day — the job's bar no longer carries a Claude key of its own, because the question is always about a day. A day with no walk says one quiet word inside its empty glass, Walk it, and a press still goes to the walk page.

It is the same orb a job's page draws for each day — one component, so a job and its days read as one thing at two sizes. New job is the last orb, dashed and empty; Unfiled stays a plain row under the shelf, because it is not a job. The Get-the-app banner and the top bar are as they were.

The day's photos, clips, notes, links and papers are small circles on an arc under its orb, each opening exactly as it did before; when a day holds more than the arc has room for, the last circle says how many more, and a press unfolds the full grid under it. The date and one soft line of what the day holds are the only words. Nothing is drawn behind an orb — no panel, no header, no cover.

A photo belongs to a walk by the clock alone: from 30 minutes before the walk was captured to two hours after it ended, to the newest walk that holds it. What is on no walk waits behind one quiet line at the end, "23 photos aren't on a walk · 2 docs", and a press opens the docs and those days. A job with no walk still opens as it did.

Gone: the drag divider, the three sample blocks, the tab switch, the Full screen line, the Google key and every explanatory sentence. What stays: the credit the licence asks for, the open-source engine link, and two plain words at the foot, Make your account and Sign in (Open the app when you are in).

The home page is a server page now: it asks the record which run the demo walk's tour is today, the same read the public /t/ link makes, and hands it to the hero. With no answer the hero keeps the run it knows. The demo's rebuilt tour (20 spots, a textured dollhouse of the rock shelf, the shelf seen from above as its plan) is live at the same link.

The shop-tour engine now runs MoGe-2 (MIT) on 18 overlapping views per stop and solves one scale per view from the overlaps. Its own metre turned out steadier than the sparse map's: the roof came out at 4.43 m from every stop (tape 4.36 m) while the map's metre against it wandered by two to one along the walk. The stops are tied together by the one height that does not change on a walk, the stick's, then registered to each other by ICP with a pose graph. The dollhouse is fused at 3 cm with a real UV atlas; the floor plan is that model rasterised from above with the roof off, the walls as dark slabs, the stops on it clickable. On the shop walk the measure error went from 17.5 % to 2.7 % (median against the tape).

On this side: the box lane knows the two new step words (sphere, register) for its stage stamps, and the engine page sends an SVG image's href to the tour's folder, which is how the plan's picture reaches the app's sandboxed page. The public demo and his proof walk are rebuilt by the box on its next pass.

Getting there took three fixes. The box only knew how to hand the engine a camera's .insv; it now hands it a stitched 2:1 equirect video too (the .insv road is unchanged), and publishes such a video as a sphere instead of pinching it as if it were two fisheye lenses. The engine itself had two gaps for stitched videos: it tried to read a lens fit that a stitched video has no use for, and its last stop had no camera height. Both are fixed in the engine.

The first cut of the walk was refused by its own privacy check: a group of school children on the lighthouse lawn. That cut was deleted, nothing of it published, and the walk was cut to the shore below instead. The engine painted 97 distant beachgoers and the walker out of the 20 stops it kept and held nothing.

Said plainly: it is an outdoor walk, so its floor plan is a line of stops with no walls and its dollhouse is jagged rock — what the engine honestly makes of a coastline. An indoor walk shows the plan far better. The demo's link runs out on November 26 and is re-minted with one command.

One page was still the second product: /walk signed out drew the sample record with its banner, while /app sends a visitor to sign in. /walk now does the same - /login, and back to /walk after.

Walk uploads from a browser fail tonight because the upload bucket refuses every PUT with 403; the page said “R2 PUT failed (403)”, which is not a sentence a worker can act on. The Walk page and Capture → Upload now say “Walk uploads are being switched on — try again later” for that answer and nothing about R2.

The three tabs will switch the one live viewer by its address alone (#tm-plan, #tm-doll, #tm-tour): the tour route adds a small script that presses the viewer's own Plan and Dollhouse keys.

Signed in, the page is reachable: /?home=1 or /home (the Android app too), and a quiet 'What a walk makes' link on the first-run screen and at the foot of the You page.

Signed out, /app sends you to sign in and brings you back to it. Every old link keeps working: / with any Record query (?open=, ?job=, ?page=…) goes to /app with the same query, and the Android app opens on /app, never the landing. Signing in, the email link, Google, the back keys and his Claude's doors into the Record all land on /app now. /photos is unchanged.

The dock is the shutter and Walk. Flashlight, Measure, Compass and Ruler moved to a Tools row at the top of Settings.

The shutter’s + stack is Note and Upload. Voice and Link left it; a group’s own + keeps them.

Not done, said plainly: the specs that pinned the old front, the Tools circle and the Voice and Link rows were not moved tonight; nothing here has met his phone yet.

The You page is your photographs. The Jobs | Photos tab and the job grid are gone from the profile: your jobs are the front of the Record and the Jobs page, so the profile does not draw them a third time.

The repo is ready to be read by strangers. The Apache-2.0 licence is installed, the app has an .env.example with every variable name and no values, and the app’s README describes the app as it is. The tests now use placeholder emails and a placeholder account id instead of the owner’s own, and his local Claude settings file is no longer tracked.

The two sheets Connect raised are still there, one press into You, Settings, This phone: Camera, Insta360 X-series, and What this phone records.

Three more 3D doors went. The Capture stack has no 3D row (the camera's own Photo, Video, 3D switch makes one), the search has no All 3D drawings row (the 3D row under the field lists every drawing), and the select bar has no 3D key (the Group sheet has a 3D switch, off until you turn it on).

A 360 walk's square on a day says Tour, the same word the front and the job's page use. And on the front, a job with a built tour wears the tour's own picture as its thumbnail.

Now the headline, one honest paragraph and the two keys sit in the first three quarters of a phone: walk a site once with a 360 camera and get a floor plan, a dollhouse and a tour, free; photos and notes ride beside the walk; the engine is open source; nothing is uploaded without an account. The three views are one row of pictures, each with its one word on it. A wide screen still sets them side by side, larger.

The line that says the engine is open source is a real link now, to its repository. Until now it went nowhere. The sample tour is fixed too: its page had never been committed, because a catch-all rule for model folders swallowed it, so the sample record could not open its own tour.

Now it is one page. Signed out, the front opens on the 360 hero, one walk in and three views out, and the sample Record carries on right below it, every action still asking you to sign in. Signed in, nothing changes: it is your Record. /360 sends you to the front. Less to manage, which is the point.

So authOrigin now keeps a page on www.tradesman.ai on its own address: a sign-up, a reset or a Google sign-in started there lands back there. The apex stays off the list (it is never a page; it 308s to www), and the Android app's address is unchanged.

Still owed: www.tradesman.ai on Supabase's redirect allow list, so a sign-in started on the public address lands back on it rather than the app's Vercel address.

The floor plan and the dollhouse pictures are inline drawings marked SAMPLE; the tour picture is the sample tour’s own panorama. Nothing claims an accuracy — the tour’s measure tool stays hidden unless its error is under 10%, and the page says so. One key, Walk one yourself, goes to /walk.

Also: “360” and “sample” are now words nobody can take as their link (the sample record’s folder had never been reserved).

Google refuses a sign-in inside the Android app, so there the key opens it in the phone's browser, which shows a six-digit code once you are in. Type it into the app and the app signs you in: the code works once, for five minutes, for your account only.

Until Google is switched on in the dashboards the key says so in words and the email form stays. The Google client, the Supabase provider switch and one migration (auth_handoff) are the presses still to do.

Reading is free: open a photo, a day, the tour, search it. The moment you press something that does something — the shutter, Note, Upload, Link, Record a walk, Import, Share, Move, Delete, Group, Rename, New job, the Claude key, Send, the You page's rows — one sheet asks you to sign in ("Your record is yours, and free."), with Make your account, Sign in and Not now. Nothing is written and nothing is redirected mid-press.

One quiet line at the top is the only thing added: "This is a sample record — make yours", with the two ways in. The old Welcome page is deleted. Nothing of a real account is ever served to a visitor — the sample is static in the bundle, and every write is refused before it leaves the page.

A task row banked in the phone's outbox before tasks were cut is let go instead of looping forever, and Sign out no longer counts it as a photo.

The front hides the days, so a photo still sending was invisible there: it now says '1 sending' or 'waiting for signal' in one line, and a link that names a day (?day=) draws that day instead of waiting on a section that was never drawn.

The exported walks app took five minutes and four gigabytes to build. The cause was one line: the default folder 'D:/walks' written as a literal, which the bundler read as a file to follow and then walked the engine's whole walks folder. It is now built at run time; the build is 25 seconds again.

If the check finds a stop that may show a person it holds the stop back and publishes nothing: the walk says it is held for your review, with the held pictures, and the tour is built only after you answer each held stop, keep it (faces blurred) or leave it out. Nothing is decided for you.

Measured on your 2026-10-16 shop walk through the box's own lane: a clear tour, 25 spots, 20 people painted out and 33 things blurred. Not on the live box yet, and the screen that asks the review question is next.

A walk the engine cannot map at all (one not recorded stop by stop, like Potomac Woods), and a live walk whose full-quality file never came off the camera within six hours, are still built the old way so they keep their tours. They are marked plainly: no privacy check on this one, people are not taken out.

The page shows every walk of yours being built as a clean room, the engine's steps ticked off as it says each is done, with a time left. When the engine is not sure nobody else is in a stop's picture it holds it, and the page says "3 stops need your eye": a sheet shows each stop, why it was held, and Keep it in or Leave it out — nothing is picked for you. Spots nobody saw stay blank; nothing is made up. A built walk opens its tour right there.

The Capture stack's 360 walk and the Insta360 sheet both open it. Pairing your own computer stays under You, Settings, optional. The review's two routes on the shop computer's side are being built beside this, so the page was proved against stand-ins and has not met a real X5 or phone yet.

A walk still being made stands in the same slot, greyed, saying how far along it is (Building on your computer, Placing them, About 6 minutes left). Stops that need your eye say so there, one press to the review. On the front, a job with a tour wears one small mark on its photograph and the word Tour in its line.

You, This phone, Your computer is one quiet line now: Linked, the address, reachable, or not reachable and a reminder about the Wi-Fi. The long paragraphs are gone. Nothing was uploaded anywhere by any of this.

You link the computer once: You › Settings › This phone › Your computer. Type its address and the 6-letter code the walks service shows (or take a photo of its code). The phone keeps the address and a token of its own; the computer keeps only a hash of it. With the computer linked, Record on /x5 no longer starts the relay to the record — the classic pull off the camera’s card is the walk, and it is sent over your Wi-Fi to the computer, which checks it whole, begins the run on the job’s name, and sends back what it received. The card’s Bring in does the same. If the computer is off you are told so in words and the walk waits on the phone — it never goes the other way by itself.

The tour is read back into the Record’s 3D row: the run says where it is (copying, building, how long is left, “3 stops need your eye”), and the finished tour opens full glass, framed from your computer under a short-lived pass that is good for that one tour. A held stop opens the computer’s own review in the phone’s browser.

Not yet met a real X5, a real phone or the real engine on this code — it is proven against a stand-in engine and a faked camera. A page on https reaching a plain-http address on your Wi-Fi works in the Android app (mixed content is allowed there) and not in a normal browser tab.

Stitched 360 walks no longer carry a sound track. Voices used to ride along with every walk with no press; Tradesman records sound only when you press record on a clip or a voice note, and now the walks keep to that.

The shop PC's sweep that puts a walk back in line after a memory failure built a web address with spaces in it, and the error skipped every job after it on every pass. The address is now written properly, and a test builds the real one.

Held stops are answered inside the app, one at a time, with the engine's own privacy_gate recording each answer. Neither button is chosen for the worker; a double tap answers one stop; a review waiting is never thrown away by starting another walk.

The app answers only on 127.0.0.1 and finished tours only on localhost, in a sandbox that cannot navigate, open windows or reach the app. Nothing here has met a real X5 or phone yet, and it is still all on the worker's own computer.

The engine now writes a manifest.json with every tour: how many stops, how big, whether the people check is complete or N stops are held, and whether Measure is shown. The app refuses a walk whose review is not complete and says which stops are held and how to look at them — a held stop is never brought into the record.

Opening a walk in the Record plays the engine's own viewer from the local copy, with notes and the dollhouse; a walk can be removed again (its copy only; the recording is never touched).

A 360 tour is no longer a section of its own. It is a square in its day, like any photo, wearing a 3D tag — press it and you walk the tour.

Every 360 walk since 1 AM had failed: the shop PC ran out of memory loading its measuring model (C: was full, so its page file could not grow). The page file is on D: now, and the eleven walks are back in line — the first built in 14 minutes.

The newest walk is measured first, so a walk you just recorded never waits behind a backlog of older ones.

Now the measuring servant says what happened in its own words, the walk lane puts such a walk back in line instead of stamping it failed, rests fifteen minutes, and only the third such try gives up — in words that say what to do (a system-managed page file on D:). The master lane's sweep puts every walk that failed that way on 2026-10-15 back in line, once.

The fix on the PC itself is the owner's: a system-managed page file on D:, and the orphan dev servers killed.

The walk is the ultimate representation of a job site; the photos support it. A walk not built yet is no face — the 3D row says where its tour is.

Each job is one square: its best photograph, its name, when it was last worked, You're here when you stand on it, and a tour mark when a 360 walk of it has been built. Tours and Sent to you are one line each, only when they hold something; today stands open; every earlier day rests under one line, Earlier.

The Record | Jobs tab is gone. The Jobs page is still there — Older, Unfiled, New job, rename, the address, delete — reached by the All line, and its ‹ comes back. You is a swipe right, as before.

So tasks are gone from the app: the day's task card, the Ahead line and its month, Plan a day ahead, From a photo, Send to WhatsApp, the task page in the viewer, what a job is owed on the Jobs page and under a job's name, and the task count on the You page. The connector's three task tools (open, add, close) went with them — the rule stands that nothing his Claude writes lands on the Record that the app can't make — and its instructions say so: a schedule or a plan stays in the chat.

The todo rows already on the record stay in the database, unread by the app and the connector; the record download still takes them home. The Record opens on today only when today holds something — an empty today no longer draws its date for a card that is not there.

Next, in this order: the front as one page (jobs as photographs, then today), and a job's face as its tour.

The sky had no measured depth, and the inpaint handed it the crane's and the roofline's — a near surface where there is none. A hole well above the horizon that no plane fills now stands as far as the farthest thing measured, so it is a still backdrop through every glide. This lands on the next tour the shop PC builds.

The minimap took a third of a phone's glass. It is folded behind one round key in the tools row now, opened on a press and remembered on the device; a press on the map still opens the floor plan.

The Tours strip is calm: one word, a count, small cards, no sentence once a tour exists and nothing about walks not built yet. And the shop PC draws no HTML 3D drawings by itself any more — each one is ten to twenty-five minutes of the owner's own Claude plan; every kit still waits Ready to draw with its Draw key.

The words say which it is now: "In line on the shop PC" for a walk that is queued, "Not measured yet — the shop PC picks it up" for one nobody asked for, and "the shop PC is off" only when it is.

And the Tours strip stopped drawing a grey placeholder card for every walk that is not a tour yet. A card is a tour you can walk; what is not built is one quiet line under the strip — "24 walks not built yet · In line on the shop PC". The count beside Tours counts tours.

Two doors on the connector now. tradesman_tour(walk_id) says where a walk's tour stands — how many spots and floors, when it was built, or why there is none (the shop PC is measuring, is off, could not) — and with share: true hands his Claude the same link the app's Share key makes, the one anyone can open for 30 days, only on his own job and only when he wants something to send. tradesman_make_tour(walk_id), the eighth write, is the app's own Measure again press made through the same core: the shop PC measures the walk again and builds its tour right after, with whatever it knows today — the camera's own stills, the spots' own depth.

Nothing on his record he could not have made in the app: both presses exist on a walk's square. tradesman_video_status now says on each walk's line whether its tour is there, on its way, or missing; the consent page names the eighth write; Where your record went counts a tour link under the links he shared, where it had landed in Other since the night before.

A TOUR, SHARED. A 360 walk's tour — the walk's own photographs spot by spot, its floor plan and dollhouse — has a Share key at the top of its glass. One press makes tradesman.ai/t/<walk>?k=… through the phone's share sheet (else it is copied and said): anyone opens it, no account, for 30 days. The key is the walk's own with the job's link generation signed in, exactly as a photo's or a day's link, so Stop sharing on the job closes it. Only the job's own person can share; a walk on a job someone put you on wears no key. The page is the same sandboxed tour the app frames, served by the same route — admitted by the key with no session — so it reaches only its own folder: never where the walk was, never the rest of the job. One ledger row a link, never the key; /privacy says it.

THE SPOTS' OWN DEPTH. Each spot's depth came off the depth splat at a sixth of the depth width — 170 pixels across — so a reel or a rail was a soft blob and the sphere smeared at every edge. Now the chosen panoramas go first to a servant in the MapAnything venv (fastx/tour_depth.py): the sphere cut into six 90° faces, the six through the net as one posed set, each face's per-pixel depth laid back onto the equirect. tour.py aligns its scale to the splat's (the walk's metre, read where both saw the same surface), lays it over the splat's depth wherever the net was sure, and keeps the splat's where it was not — the floor, the ceiling and the plan still come off the splat. NEVER A GATE: no venv, a failed or slow servant, a metre that does not fit — the tour builds on the splat alone and the report says why. The page tears a sliver at half the old step when the spots carry the sharp depth.

On the bench: the face round trip lands within 2% of the truth over the whole sphere, an unsure face leaves a hole and never a guess, a net at the wrong metre is refused, and the lane hands tour.py the venv only when it is there and the switch is on. NOT DONE, said plainly: the GPU run itself — the first real tour after the box pulls this is the measurement; a tour link has met only a headless browser.

Found tonight: a sub-agent in this harness cannot do the work — every one is handed the whole project file before it reads a line and runs out of room in three turns. The night's building was done in one session, kept lean.

With the camera tracker, the walked trail could bank a jump when the camera relocalised, a teleport the tracker's own distance already refused. The floor run now skips any segment of 3 m or more, matching the plugin. And on a desktop the Tours strip bled past the job page's scrolling work column and made a 24 px sideways scroller; it now bleeds to the edge only on a phone.

The prop is gone, tsc is clean but for the two files that need Prisma’s own types, and the day-rest and tour-strip specs pass. The law for next time: a tsc error in a file this push touched is never pre-existing.

Now Tours is the first thing under the Record's bar, on every job and on one, and first in what a job runs on: one line that says what a tour is, over a strip of your walks edge to edge — a built tour opens full glass with a press, a walk still on its way stands greyed with where it is (waiting for the shop PC, being measured, the tour being made), and the strip always ends on Record a walk, the door to the X5's own screen. With no walk at all, that one card and the line stand alone, so the way in is never a secret.

The jobsite is the atoms. The X5 is the bridge. The tour is the bits.

On the Record a day's squares run edge to edge, 2 px apart, no corners — the same grid as the profile's. A group or a set is its plain title row over its squares: the name, what it holds, and its + and ⋯; opened on a day that is over, the title row is the Show less key, with a chevron up at its end. The day's tasks are plain rows under one line, the add field a line on the page. Model is a word. On a job's page the face runs edge to edge, Directions and Paste text or a table are plain keys, and Docs and 3D are plain rows.

The dark switch left the Record's and the Jobs bars, as it left the You bar on October 10. It lives in Settings: You › gear › This phone › Appearance — Phone, Light or Dark. The browser's bar now wears that choice on every page, which until today only a switch's mounting had painted.

Nothing here has met the Razr; the harness proved every screen at 412 and 360, light and dark.

Now its clocks are in seconds, not samples, the jitter is smoothed, the mean moves slower than a step, and the bar adapts to how hard you are actually stepping — never under 0.35 (a phone on a bench still counts nothing) and never over the old bar. One jolt of the phone is no step at all: a first footfall is held until a second lands, then both count. On the bench a walk at 0.6 m/s² counts exactly, at 30, 50, 60 and 100 Hz alike; standing still, a truck's rattle, one jolt and standing up all count zero.

With the camera tracker (the Android app), the run was the tracker's own sum of every 5 cm move in all three axes — the hand's bob and sway rode on it, a few percent long on every walk. The run is now the tracker's trail in the floor plane, banked at 15 cm, which a hand's sway never crosses.

Not proven on the Razr: the bench is synthetic. Walk a known 50 ft and the calibration says how close it is.

Now every 360 walk stands in the 3D row from the moment it lands, greyed out until its tour is built, with one line saying where it is: Waiting for the shop PC, Waiting for the shop PC — it is off, Measuring the walk — the tour comes right after, Making the tour…, or why it could not be built. Pressing it says the same thing and opens nothing. The row counts the tours that open and says how many are on the way.

A phone clip that came in as a walk gets no row — it plays flat and never becomes a tour.

Now it tries three times, and when the memory was full it waits 45 seconds before the next try. The memory frees up and the walk goes on. A real crash still fails the same way it did, without the wait.

The real fix is a bigger paging file on the shop PC. That is a Windows setting only Kymani can change.

Now, when the shop PC has a walk's own camera file (the .insv), it stitches each tour photo again from that file, as a still, with Insta360's own stitcher, at the camera's full width (up to 7680 pixels across). It tries Insta360's AI stitching first, which is made for things close to the lenses like the stick and your hand, then its optical-flow stitch. No video compression sits between the camera and the tour, and the remap that caused the seam is gone. If any of that fails, the tour is built the old way and the shop PC says why.

A walk recorded through the app is still streamed in first, so it is in your Record within a minute. It is also on the camera's card at full quality. Once the camera is idle after the walk, the app now copies that card file off by itself and gives it to the same walk. The shop PC then restitches the walk, rebuilds its tour from the real footage and replaces the soft preview. It is the same walk, on the same job and day. While it copies, the pill says "Full quality". Pressing Record first just puts it off until the camera is idle again.

Walks streamed before today: open Walks on the camera on /x5. A walk the record recognises by when it was recorded shows "Streamed into your Record" and a Full quality key, so it is never filed twice. Older walks uploaded as .insv files, like Potomac Woods, are measured again once by themselves.

In the tour, the spot you're standing at swaps in a sharper 6144-pixel copy once your screen can show more detail than the normal photo. That happens on a wide screen, when you zoom in, and on a phone held upright. Only one sharp copy is loaded at a time.

Not proven yet: none of this has run on the real Insta360 stitcher, the shop PC or your phone. The box picks it up on its next idle update, and your next walk is the real test.

One press on Bring in copies that walk off the camera, keeps it on the phone, and sends it to the shop PC like any walk: it gets stitched, gets its frame shelf for your Claude, and gets its tour. It lands on the job the Record is open to, or Unfiled, and on the day you walked it, not the day you copied it.

A walk already in your Record says so and opens there; one over 5 GB says it is too big to send in one piece before anything is copied. A walk that copied but did not send stays on the phone and says so, with Send or Forget, and it is never copied off the camera twice. The camera always keeps its own copy, and the phone's copy is deleted once the Record has it.

Nothing new to install: the app you have could already do this (we had cut the button on Oct 8 as unused). While it copies, the camera's live picture steps aside and comes back by itself. While the camera is connected, the upload goes over your phone's data.

On the Record, a day you have not opened is no longer a row with little stacked thumbnails. It is the day’s name and where you were, over four of its photos edge to edge — the ones that show the place first — with “+12” on the last for the rest. Tap it to open the day, as before.

The Ahead line lost its grey box. Open days, with their task cards, look the same as before for now.

Two buttons: Share my link, and Edit (your name, your link and whether it is public). Your crew is a row of faces; tap one to open your crew, or the + to add someone.

Under that is your work as a photo grid, edge to edge: Jobs, each shown by its best photo with its name and how many photos it holds — tap one to go into the job — or Photos, newest first.

Everything that used to be a row on this page — your Claude, your record, this phone, help, sign out — is behind the gear at the top right, under Settings, exactly as it was.

The photo sphere stays exactly where the camera was; only your eye moves. Seen off its centre, a depth sphere stretches what’s close, so the move is capped by how near the room is in the direction you move — full in open space, part-way when a reel or a person stood within arm’s reach of the camera — and the sphere now tears cleanly at depth edges instead of smearing, with the nearest other spot filling the holes (the glide between spots got cleaner for the same reason). A switch under ⓘ turns the levelling off on that device if you ever want a spot exactly as shot.

A walk’s square on the Record now opens straight on its tour, wears a small Tour mark, and says “Making the tour…” while the shop PC builds it — never waiting on one that isn’t coming (a tour that couldn’t be built says so to the app). The footage on the sphere, the 3D drawing, Move and Delete are one key away inside the tour: 360, top right. The 3D row still lists every tour.

The seamless path, then: Connect → Insta360 → Record a walk (or Capture → Upload a 360 video) → the walk’s square says Stitching, then Measuring, then Making the tour, then Tour — one press and you’re inside. Nothing here has met a phone or the live box yet; the first real walk after the box pulls this is the proof.

A job link that was already used, or is more than a week old, now says so and tells them to ask you for a new one. Before, it quietly turned into a crew request they never meant to send.

Before your link exists, the You page shows the link it will make, and you can change it right after. The privacy page now says anyone who types your link can open it.

Under it is one switch: Public. It starts off. Turned on, a search engine is allowed to list your page — it shows your name and lets people ask to be on your crew, nothing else. Turned off, only people you send the link to can open it.

Public links are listed in the site map search engines read, and only those. Turning your link off turns Public off with it.

A measure tool lets you drop two points and read a length. The shop PC often can’t trust its own metre, so the tour says “uncalibrated” until you tap Calibrate on one line whose real length you know — then every measurement uses that scale. Notes you drop stay on this phone for now.

It opens from the 3D row on the Record, under its own stamp: your 360 walk, the photos as shot, depth and sizes approximate. The page runs sealed inside the app like a drawing does — it can reach its own files and its 3D engine, and nothing else.

What it isn’t yet: a tour needs the shop PC’s walk measuring first (about five minutes), the person holding the camera is in the photos, and a walk the solver couldn’t tie together comes out bent. Those are the next things.

A job now opens on its photos, the ones that show the place, like the panels in the basement and the meter on the brick wall. It skips the forms and nameplates. Tradesman picks them from what each photo was read as showing.

Under the photos are the job’s name, where it stands, its address and who’s on it. You can change the address right there or press Directions. Then come tasks and docs, then every day’s photos, already open.

On a computer, tasks and docs sit on the right and stay put while the photos scroll on the left.

A day with only one or two things on it now shows them instead of folding them into a square you have to open.

Jobs load faster. Since job sharing went in, the job list was taking up to four trips to the database. It takes one now, about a fifth of a second.

Whoever opens it sees your name and nothing else, and can ask to be on your crew. You say yes or no in your app, and a no is never shown to them.

Showing your code in person still joins in one press. Texting someone onto a job still puts them on your crew and the job in one press. Both links now say tradesman.ai and your name.

Where your record went can’t be padded by a stranger any more. Someone who saw one of your job IDs in a shared link could post fake activity under it. Now activity only counts on a job if the person owns it or you put them on it.

A typo in your email no longer strands you. "Wrong address? Fix it" takes you back to the form with your name and password kept.

Forgot your password? The email's link now works in whatever browser it opens. Before, it only worked in the browser that asked, so a reset asked from the app could never finish. A reset asked from tradesman.ai no longer lands on the old address signed out.

Connecting Claude: when you come back from Claude, the card says Connected and the Claude key stops blinking at you. Before, it kept asking until you reloaded. And the Connected line no longer says Claude has read your record before it has.

Where your record went now keeps counting what someone did on your job after you take them off it. Before, their reads disappeared from the count the moment you removed them.

Deleting your account now says that what you added to someone else's job stays on their job. The download page says those photos aren't in it, because they're on their job.

Tradesman's own emails, once they're switched on, open a page with one Continue button instead of signing you in the moment the link is opened. Work email scanners open links before you do, and that used them up.

Where your record went now counts the people on your jobs. This morning Sergio's Claude read your jobs 6 times, and he opened them in his app 4 times. You see counts only.

The privacy page now says plainly what a shared job shows. A photo or note someone else adds to your job now records who added it. The person you shared with is told that what they add stays on your job.

The database also starts every new function and sequence closed to the app's public key, the way new tables already were.

Connecting Claude is one press. Claude publishes a link that opens its own Add dialog with Tradesman already filled in. Press Add, then Connect, then Allow. The copy-the-address steps are folded away for the rare Claude that opens without the form. If Claude's Allow page finds you signed out, it now asks you to sign in first, not after you press Allow.

Adding someone to a job is one text. On your job, People on this job has "Text them a link". They open it, make their account, press Join, and they're on your crew and on the job together. The page they land on explains the three things you had to teach Sergio by hand: the shutter, Jobs, and Claude. It also gives them one press to open the job and one to connect their Claude.

Make your account now asks for your name. Where you were going, such as a crew link, survives the confirmation email. Someone you add by email before they've joined is asked the day they do. Before, that add was quietly lost. Your Record now says "Kymani put you on 326 N Stonestreet" when someone shares a job with you.

Tradesman's own emails are written: confirm your account, reset your password, change your email. They come from Tradesman, in Tradesman's words, and their links work in any browser on the phone. They go live once you give the app a Supabase access token, or paste them in the dashboard. That step also puts www.tradesman.ai on Supabase's list. Right now a reset started there sends you back to the old address, signed out.

The full names are in the People on this job sheet, one press away on the job's ⋯.

A job someone shared with you has a ⋯ there too. It only says whose job it is and lets you leave it, because renaming, moving and deleting stay with the person whose job it is.

The work it asked for already shipped on October 4: the You page, the welcome screen, seeing where your record went, downloading all of it, and deleting your account. The thesis is now the tiebreaker when a decision is hard.

When a 4D video is ready, the card now says that the people in it go with the video. A saved or shared copy is yours to keep, and deleting the clip doesn't reach it. The privacy page says the same.

In the Android app, Save now writes the video a few megabytes at a time instead of as one huge block. A 40-second 4D is about 40 MB, and handing that to the phone in one go could freeze the app. It hasn't been tried on your Razr yet; recording one full-length 4D and saving it is the test.

They can add to it. A photo, clip or note they take on that job lands on it for both of you. Tasks stay personal: you never see each other's tasks. The job is still yours. Only you rename it, change its address, delete it, move or delete things on it, or change who is on it. They can leave it from the same menu, and taking someone off your crew takes them off your jobs too.

Adding each other now works like a phone's contacts. If someone already asked you to join their crew and you add their email, that counts as your yes, and you're on one crew right away.

Before building this I checked who could read the database directly. The public key that ships inside every copy of the app could read every account's photos, notes, places, walks and history, and could write to them too. That's closed now. Every table refuses that key, and only the app's own server can read your record. Nothing you use changed, but it should have been closed from the start.

When you send a whole day by email, the Send sheet now says what that link is before it goes. It shows the day as it stands when they open it, with its Model, which shows where each thing was taken.

When some of what you picked can't go by email, the sheet says so. A saved link or a paper can't get a public link, and one email holds ten links at most. The subject line now names only what actually went, so it never says "3 photos and a paper" when the paper was left out.

If someone says No thanks to joining your crew, that answer is kept. Adding them again, saving their contact again, or taking them off and back on never asks them a second time. You get the same answer either way, so nothing tells you whether they have an account. It changes only if they reach out to you.

I went through this week's logs for things that failed on you, so you don't have to find them by using the app. Most of it was healthy: every photo was read and code-tagged, your streets all filled in overnight, and none of your tasks are late.

One real problem turned up. On October 6 the shop PC's Claude lost its sign-in partway through, and the box treated that as a crash. Your Wildewood rebuilt site and a 3D clip from that day were tried twice, then left saying "Claude stopped partway twice." Now a lost sign-in counts as signed out, not a crash. The shop PC waits, tries again every half hour, and draws once it is signed in. It is signed in again, and both drawings are being drawn now.

Now every point is a soft splat, and the splats on one surface are blended into each other. The lift's deck, its rails and the ceiling read as surfaces. The worker in your clip is a person with the stripe on his vest, where before he was a scatter of dots. Everything that moved gets larger splats again, because the shop PC samples moving things more sparsely than the room.

In Trail and All, the room is drawn a little dimmer and greyer, so what moved stands out from what stood still. The moments just before now are ghosts laid over the room.

When the 4D opens, the view sways slowly side to side as the clip plays, because that movement is what makes it read as 3D. It holds still while paused, stops at your first touch, and comes back with a double tap. It never sways if your phone is set to reduce motion.

I tested it on your three RoadGuard lift clips. It is still points from one phone video, not the trained gaussians in his video. Training gaussians per moment is the next step up, and it would take far longer than the 4D does now.

Someone on your crew gets it straight into their Tradesman, as before. Anyone else gets an email from your own mail app, holding a link for each photo or one link for the day. The email comes from you, not from us. Tradesman never sends mail or keeps a copy, and the sheet says to press send there.

If the address you add belongs to someone who uses Tradesman, their app asks whether they want to join your crew. It takes their yes too, and nothing is shared until they say it. If they don't use Tradesman, nothing happens and nobody is told. The app never reveals whether an email address has an account.

The Ahead calendar now opens on the month alone. Press a day and you see that day's tasks and can add to it. When you want every day ahead at once, one row under the month opens the whole list.

Copying a public link is still there as the last line of the Send sheet. A contacts list only helps if the person is in it.

A photo or note that Sergio or Alex sent you can no longer go out on a public share link, either on its own or as part of a shared day. It came with their note and where they took it, and that stays between you and them. When you open one, there is simply no Share on it.

Links that only you open, like the ones your Claude gives you back into your Record, go to the address you are signed in at, which is the one the Android app uses. Opened on tradesman.ai, they would have shown you the sign-in page. Public links (a shared photo or day, the address you give Claude) still say tradesman.ai.

Crew links and the code that puts the app on another phone stay on the old address for now. Someone making an account from one gets an email to confirm, and until tradesman.ai is added in Supabase that email would drop them on the wrong page. That Supabase step is the one setting still waiting on you; once it is done, these move to tradesman.ai too.

Each row shows the day, where you were, what it holds, a few of its pictures, and any tasks that are open or late (late in red). Press a row and the day opens right there, exactly as it looked before: its tasks, its photos, its notes. Press the day’s name to close it again. Opening the app always starts with every day closed.

Nothing that needs you is hidden. A day with a photo still sending opens by itself, so you still see a shot the moment you take it. If you close it anyway, the row says what is still on its way. A link to a day, a search and a group open what they show.

The 3D row is gone from the top of the Record. It now sits in the search: press the magnifying glass and it is the first thing there, before you type a word. A job’s own page still shows its 3D under its docs.

The Claude key now glints every few seconds: a light passes over it and the spark turns once, in the app’s own black and white. Until someone’s Claude is connected it glints twice as often, so new people notice it. Tradesman is at its best with Claude.

A crew link now lets in one person. The moment someone joins with it, it stops working and your next code takes its place, so a link forwarded into a group chat can’t bring the whole chat onto your crew. While your code is on the screen, the card tells you who just joined. If someone joins through a link you sent, the top of your Record says so, and pressing it shows your crew, where you can take them off.

What someone sends you stays with you. If Sergio sends you photos, you can’t send them on to Alex, and Send this day leaves them out, along with your Unfiled photos, the way Share this day already did. Sergio’s photos carry where he took them, and that stays between him and you.

Your downloaded record now says who sent each item that came from your crew, so a coworker’s photo is never listed as one you took.

The Android app keeps running where it was. A page’s sign-in and the photos waiting to send belong to its address, so moving the app takes a new Android build that sends what’s waiting first. Until every phone has that build, the Vercel address keeps serving exactly as before, and every link already sent still opens.

Two settings were left for you to press, because the dashboards would not let me sign in or open the key. In Supabase, tradesman.ai goes on the list of addresses a sign-in may return to, so someone who makes an account from a tradesman.ai link gets back in after confirming their email. In Google Cloud, it goes on the Maps key’s websites, so the 3D ground shows on tradesman.ai.

Your crew lives at the top of the You page. Add someone shows your code, which they scan with their phone's camera, or a link you send them. They open it and press Join, so you both said yes. Each person shows by name, and their ⋯ takes them off your crew after one ask.

Sending works from three places. A photo's Share now offers your crew first and the old link after it. Select mode has Send. A day's ⋯ has Send this day to your crew. Tick one person or both, press Send, and it tells you what happened in plain words.

What you send lands in their Tradesman as their own copy. It keeps when and where it was taken, your note, what was read off it and who sent it. WhatsApp strips all of that, which is why your heavy-up photos came in with no location. Your tasks never go, and they never see anything else of yours: not your jobs, not your days, not where you are.

When someone sends you something, one line at the top of your Record says so: "Sergio Galindo sent you 2 photos and a note · Herndon Pkwy". Press it to see just what came in, then file it all to one of your jobs with one press. The job with the same name as theirs is offered first.

The You page is simpler too: you, your crew, then Your Claude, Your record and This phone as three rows that open in place, each saying what it holds. Nothing was taken away; every row is one press further in.

And the reviewer's latest four points are fixed. A day's link can no longer include your Unfiled pile, even from an old version of the app. The doors that hand out lasting access now check your sign-in with Supabase itself. A video's share link says it can still carry where it was filmed. A long note you pasted stays editable.

Delete asks once, the way every delete in the app does — "Delete this photo? It's gone for good." — with Keep right beside it, and then the review moves on to your next shot the way a phone's gallery does. The strip, the count and what the Record shows when you press Done only count what you kept.

It works no matter where the photo is: still being saved on the phone, sending, waiting for signal in a basement, or already in your Record. A photo you delete before it has gone up is never sent; one that was already on its way and lands anyway is deleted the moment the server says it has it; one already in Record is deleted there. Clips and 3D captures delete the same way, and a clip that didn't go up has Send it again right there too.

Escape, the X and Android's back put the review away and leave you shooting. Open in Record still takes you to that photo in your Record, the way pressing a thumbnail used to.

And on the Record itself, a photo you've just picked from your phone could not be deleted for its first moment, before the phone had saved it. Now it can, and it never sends.

The errand know-how didn't go away: the Tradesman connector teaches every Claude how a report, an inspection request or a plan goes well, so when you ask for one in the chat, it does it the careful way — links anyone can open, numbers checked on the photo, nothing added you didn't say.

The key is easier to understand now: on your phone it says "Claude" under the black mark. That's as far as Anthropic's rules allow — the name in plain words, but not their logo, and nothing that reads like an official partnership. That's also why the sheet is called "Work with Claude" now, not "Claude × Tradesman".

And the chat goes on the record: after you press, the sheet offers "Keep the chat on Vitronics's day — paste its link here." Claude's app doesn't hand its chat link to other apps, so it takes one paste, and then the conversation sits on that day of that job with your photos.

Under the head the job reads top to bottom. DOCS come first and are open, not tucked behind a row: the schedule, the diagram, the PDF, the gate code. TASKS come next, with today's list (late ones included, still foldable) and the Ahead line with its calendar. Then DAYS, the photos and notes by day, the same grid as always.

You can paste a list or a whole table straight into a job. "Add a job doc" now leads with "Paste text or a table". Copy rows from a spreadsheet, paste, press Keep it, and it becomes one note kept with the job, exactly as you pasted it. The app draws it as a real table, on the doc's row, on its own page, and on its square, and a wide one slides sideways inside its card without the page moving. Your Claude still reads it as plain text.

Back goes where you came from: the Jobs page if you opened the job there, otherwise every job. Android's back button does the same, and at the top of the Record it still sends the app away. Capture inside a job files to that job, and the Capture menu says so ("Files to Vitronics"). Unfiled isn't a job, so it opens the way it always did. Changing the address is one press on the street under the job's name. The job map and the crew you mentioned are not built yet.

So the Claude key now opens Work with Claude: those errands as buttons. Report with photos, Inspection request, Put a plan in, Plan the week, Find it, Order parts, Draw the plan, Catch me up. Each one opens your own Claude with the job written out the way your best sessions went: which tools to use, numbers checked on the photo before they go in an email, links anyone can open, nothing added that you didn't say. A coworker presses the same button and gets the same Claude you do.

It works on whatever you're looking at: your whole record, a job, a day (from its ⋯), the photos you picked (the key sits on the select bar), or the photo you have open. There's one box for your own words, typed or said — who it's for, what to say, or a whole plan pasted in — and they go with whichever button you press.

When you press one, the words are copied as well as typed into Claude, and the sheet says so. If Claude opens empty on your phone, just paste. That's the fix for the button that wasn't working.

Your Claude also got faster at reports. It can now pull up to twelve photos by their short IDs in one go, with their share links, instead of one at a time — on October 5 that was 95 separate lookups. And the connector now teaches every Claude these errands, so a coworker who just types "email the inspector about Redland" gets the same careful result.

Tradesman works with Claude, and only Claude — that's a written rule now. The help page explains every button, so you can send a coworker there.

Back on the Insta360 screen no longer drops you out of a walk. A stray swipe while you're recording now does nothing, and the screen says "Recording — Stop ends the walk." Once the walk is saved, back works as usual.

Nothing pretends anymore. A job doc your Claude kept now says "Kept by Claude." A search hit found in the words a machine read off a photo now says "machine read," so a permit number misread by a digit doesn't sneak into an email. Photos with no GPS that were placed at the job's address now reach a rebuilt 3D site as "at the job's address," never as the spot where you stood. The app's Where your record went page and the privacy page now name the address-search services the Jobs page uses: OpenStreetMap, Google and OpenCage.

Sharing got safer. "Share this day" no longer sends your Unfiled pile along with the job, since personal shots end up there. A photo in Unfiled can now stop its links from its own ⋯ menu. A day link can no longer be used to flood your call log. A PDF is now checked once it's uploaded: anything that isn't really a PDF, or is over 25 MB, is deleted and refused.

Under the hood: after the Supabase key switch, a session you signed out of could keep working for up to an hour. That's fine for reading, so every place that saves something for you now asks Supabase directly whether you're still signed in. Bulk delete now warns you when it would take a whole group and its 3D drawing with it, and counts any picks hidden inside folded squares. Your Claude is no longer told notes land in History, a screen that's gone. The leftover push table is dropped. And PDFs now get short IDs too: your two papers became #79 and #HY.

The dead code underneath went with them: five files nothing used, the Claude cam (it never once fired), the shop PC's people tracker (switched off since Oct 4), the old sprite art, and two map libraries. The 3D points viewer stays, since you left it unticked. So does the 360 frame shelf, which is how your Claude reads a walk second by second.

Camera shifts still work: Let Claude watch on the Insta360 screen starts one, and your Claude reads what it kept. A job's ⋯ menu now has "Stop sharing this job", which closes every day link and single-photo link to that job at once. It asks first. An old /field link opens the Record instead.

One thing found along the way: the shop PC's walk-to-3D lane borrows the people tracker's detector to keep crew out of its drawings. That part stays, and now stands on its own.

Four passed only on a second try. Two of those were real: tests that check the Connect sheet makes no network calls didn't yet know about two quiet reads the Record makes on its own. They know now, and pass on the first try.

Info (when, where, the note, the code) moved to a small ⓘ at the top right, next to the count. It's still one tap, and swiping up on the photo still opens it.

Now the tray has a 'Make a group' key at its top. Press it and the Group sheet opens with every photo of that set already picked — name it if you like, then Save. And since a group now stands as one spot on the day's model, that's also how you tell Model my day 'these are all the same pole.'

The new Android build (1.1) uses Android's own speech recognizer instead — the same one the Google keyboard's mic uses. Your words show up as you talk, a pause doesn't end it, and Done waits for your last few words instead of cutting them off. Until you install 1.1, the Voice screen says plainly that it needs the update rather than pretending to listen.

The same update fixes the back button at the very top of the Record: it now sends the app to the background like any Android app, instead of doing nothing. On pages like Privacy or Help, back now steps back to where you were.

The app will show 'App update ready' at the top of the Record — Download, then open the file.

Now there's one row for it. On the Record (and on each job, next to its job docs) a single line reads '3D · 5' with the first names under it. Tap it and it opens in place: every drawing, rebuilt site and 4D clip, newest first, each saying what it is and when. One press opens it — a drawing on its drawing, a 4D clip straight into its player, a rebuilt site full screen with Plan a build at the top.

The row only shows when you actually have something in 3D, and it stays folded to one line unless you open it.

Picking used to be hidden behind a long-press nobody tells you about. Every day's ⋯ menu now has 'Select — move, group or delete'.

And a photo's ⋯ menu no longer runs up over the top of the screen on a small phone; it stops under the top bar and scrolls.

Now it does. Open search and type a permit number, a serial or a maker's name, and the photo it was read off comes up — the row says 'Read on it' (or 'Seen in it') and shows the number itself, so you can see it's the right one before you open it. Press Enter and the Record narrows to those photos.

Those words come down once when you open search (about 150 KB for all your jobs), never when the app opens, so opening the app is no slower.

Inside the Android app, the back button did nothing on the Record. The app hands every back press to the page, and only the old /field screen was listening — so back couldn't close a photo, a menu, a sheet or the camera, and it couldn't take you from Jobs back to the Record. Now back closes whatever is on top first (a photo's details before the photo, a menu before the page under it), then steps back from Jobs, You, a group or picking. A note you were typing is kept when back puts it away.

One thing still waits for the next Android build: at the very top of the Record, back does nothing instead of sending the app to the background.

The slowest app open on record spent 8.5 of its 9.2 seconds asking Supabase whether you're signed in — a round trip on every single request. Every route now uses the check that can happen on our own server instead. Right now it still makes the round trip, because your Supabase project signs sessions with an old shared secret. Flip one setting (Supabase → Project Settings → JWT Keys → Migrate, then Rotate) and every request skips it — nothing else to change.

Now what you took of one thing stands as one spot. A group you made is one spot when its fixes sit close together; loose shots taken within a couple of minutes of each other (or in one opening of the camera) join it when they are within their GPS error. The spot stands at the middle of the fixes, leaning toward the better ones, and zooming in never pulls it apart — a press opens it as '1 of 5 taken here'.

Nothing is rewritten: each photo keeps its own fix, and its card says it plainly — 'Stands with 4 more · its own fix 6 m off, ±7 m'. The circle on the ground holds every fix of the spot.

The camera also takes a better fix now. It used to stamp the newest reading the phone had; now it keeps the last 12 seconds and stamps the most accurate one, allowing for how far you might have walked since. GPS itself doesn't get better — the camera just stops throwing away the good reading.

Now there's one key for it, in the same place on Record, Jobs and You: the black spark at the top right of the bar. Press it and Claude opens with the first message already typed in — today's date, and the job you're looking at if you've narrowed the Record to one — asking it to get up to speed on your record (your jobs, today's photos and notes, what's still open), tell you where things stand, and ask what you're working on. Then you just say what you need.

If your Claude isn't connected yet, the same key opens a short sheet instead: the connector's address with a Copy key and the three steps to add it in Claude's settings. That's the part that lets anyone else you hand the app to get the same thing you have.

On a computer the key also shows its words, "Work with Claude". On a narrow phone (under 380 px wide) the Record · Jobs · You tabs tighten slightly so everything fits on the bar.

Not proven yet: whether pressing it opens the Claude app on your phone or claude.ai in Chrome is up to Android, and whether the app keeps the typed-in message hasn't been tried on your Razr.

And the line no longer shows the far end of a schedule: it used to read "Ahead · 15 tasks · through Wed, Nov 4" — on October 6. Now it says "Ahead · 15 tasks", with the next thing owed under it.

Now the Ahead line is always there above today — "Ahead · nothing planned yet" when it holds nothing. Open it and it starts with a month: today ringed, past days greyed out, a dot under every day that has tasks. Tap any day ahead and that day's card opens below with its add box ready, the cursor in it. A day with nothing on it yet just appears in the list for you to fill. Tapping a day's name in the list does the same, and ‹ › walks a year ahead.

It's drawn from your tasks, not kept beside them — a task you add on a day is a task due that day, the same one your Claude reads, so there's nothing to keep in sync.

The face above it still opens the job, and the ⋯ still holds Rename, the address and Delete — the line sits under the face, not inside it, so a press always does one clear thing.

Also fixed: the Where your record went page said a shared day's link carries its tasks. It never has since October 6 — tasks are personal — and now it says so.

Now each job is what you know it by: its newest photo as its cover, its name, its address — with "You're here" when you're standing on it — and where it stands: when it was last worked (Today in black), what it's owed ("3 to do", the late ones in red), and how much is on it. The top of the page says how many jobs you have and how many tasks they're owed. Press a job anywhere and it opens on the Record.

Changing a job is one ⋯ beside it: Rename, Add or Change the address, Delete. Each still opens right there in the job's row, and Delete still asks first and hands everything to Unfiled. A job with no address keeps one plain "Add the address" line under it, so the one thing missing stays one press away.

Not done: nothing here has met your phone yet. The address is no longer a key on the row itself — it lives in the ⋯ (and in the Add line when it's missing). If you liked tapping the address to change it, say so and it goes back.

Job docs give the things you need for a whole job (a schedule, a wiring diagram, a reference) a home that doesn't sink under a week of days. When the Record shows one job, a row under its chip reads "Job docs · 3". It opens in place, and each doc opens in the viewer, where you can swipe through just the docs. "+ Add a job doc" saves a link, takes a PDF or a picture from your phone, or lets you pick what's already on the Record. Any photo, clip, note, link or PDF can be kept or taken off from its ⋯ (a note or a link has its own Job doc key). A doc stays in its day too, wears a small bookmark there, moves with its job, and goes if you delete it. The Jobs page counts each job's docs. All jobs and Unfiled have none.

Your Claude can keep things as job docs too: it has a seventh write, tradesman_keep_doc. tradesman_list_jobs lists each job's docs by name and short ID, and a day marks a doc's line. Saved links aren't called "pinned" anymore.

PDFs come in. Upload and the job docs picker take them. A PDF files as a paper, the record's own kind for papers, and goes straight to storage on a signed upload. On the Record it's a square with its title and "PDF · 6 pages". Its page has one Open key, which hands it to your phone's own viewer and never shows it inside the app. No model reads a PDF when it comes in.

Where your record went counts it when your Claude keeps a job doc for you — among the things it added when you asked, never as a read.

Not done: none of this has been on your Razr yet. The app never shows a PDF's pages itself, because your phone's viewer does. A group can't be a doc. Papers get a short ID only once the migration in this change is run (20261007_paper_ref.sql), and I haven't touched prod. Papers from the old engine-room upload now show up on the Record in their day too.

Share also stops naming a job that only had your tasks that day, so a coworker's link can't open that job. A day that holds nothing but tasks has nothing to share, so it doesn't offer Share. Links you already sent drop the tasks the next time they're opened.

Now a shared day reads the way your Record does. Each group sits on the same grey tray under your name for it, with what it holds ("Pole 4 · 2 photos"). A set you shot in one opening of the camera sits on its own tray. Loose photos and notes sit between them. Everything is newest first, like your Record, and the jobs go in the order you last worked them. Opening a photo and pressing next walks the page in that same order.

A group you never named says "Group" on the link. Your Record names those from what the photos show, but a shared page never gives out what a machine read off your photos. Name the group in its ⋯ and the link says your name the next time it's opened.

Now every open group on today wears Show less, and it works. Fold it and it stays one square, even when a new build reloads the app, until something newer lands in it. Then it opens again so you see it went in. Adding to it through its + or the Group sheet opens it too. The one thing that never folds is a group with a photo still sending, so a 'waiting for signal' is never hidden from you. A set taken together in one opening of the camera folds the same way.

The link shows the day as it stands when it's opened, not a frozen copy. Share it in the morning and it fills in as you work — a day that is today reads itself again every two minutes while it's on their screen. A day with only its tasks (the morning plan, before the first photo) can be shared too: its ⋯ now shows when it holds tasks.

The Model comes with it, as you asked mid-build: where the day has anything with a place, the shared page wears the same Model key your Record does — every photo, clip and note standing where it was taken, on the site, and a press on a card opens it in the shared page's own viewer. It's read-only there: no rebuild key, no plan key, none of your rebuilt sites. Its satellite view is asked with the link's own key and only within a few kilometres of where the day happened; on the live site it streams the 3D ground like yours, and that call is written in your ledger under the job.

What it shares is what's on your Record under that day's stamp: on All jobs, every job that day touched; on one job's page, that job alone. Photos go out as fresh copies with no GPS, clock or camera in the file (the same clean copy a one-photo link sends) — but the Model does show where each thing was taken, which is the point of it. 360 walks and saved links stay off the link, and its foot says how many were left out.

It opens for 30 days. Stop sharing is in the same ⋯ (this phone remembers which days it shared) and asks first, because a link can't be taken back on its own: it closes every link to that day's jobs — the day's, the job's own, and any one photo's. Where your record went counts day links on their own line, and /privacy says it.

Not done, said plainly: a shared clip still plays its stored file (the same as a one-clip link); a 360 walk isn't on the link yet; the shop PC's rebuilt site of a day isn't shared with the day; and none of it has met a real coworker's phone yet.

Two checks run beside the people-finder now. The first looks for each point of a frame in the other frames: if they see straight through the place where it was, it moved. The second follows the picture itself from frame to frame and asks whether a still world could have moved that way, given how the camera moved. That camera motion is worked out from the two pictures themselves, never taken from the 3D solve, because the solve's own small errors had made a tree trunk read as moving.

Measured on a test scene of a lift deck rising in front of its own scissors: the first check saw 21% of the deck, the picture check sees over 80%, and it calls nothing still moving whether the camera turns or walks. On your crew clip, the gray-gloved hand the people-finder missed now moves. Your truck counts where it drove. On your lift clip only the workers move: the lift never rises there, and the phone only turns.

Its limits, said plainly. A car or truck counts only where one of the checks saw it move, because the people-finder sees motorcycles in a pole base's wiring. Nothing lying within 15 cm of the floor counts as moving, because the road under a phone pointed down never holds steady. Something moving exactly along the camera's own line of travel shows only where it uncovers what was behind it. It adds about half a minute a clip on the shop PC, still free.

The reviewer on issue #29 caught two things about the 4D, both fixed here. The privacy page said the shop PC finds people only on camera shifts you turn that on for, but making a clip 4D keeps the people in it in 3D, frame by frame. The privacy page and the Make it 4D button now both say so. And the file the shop PC finds people with could have been quietly downloaded in the middle of a run without a line in the log. It now loads only from the shop PC's own copy, checked against its fingerprint, and if it's ever missing the 4D stops and says so.

One choice is yours: should the people in a 4D keep their colour, become plain grey shapes unless they agreed, or should Make it 4D ask you each time? Until you say, it stays as it is, in colour.

Open any phone clip and press More, then Make it 4D. The shop PC turns every frame (six a second) into 3D. The parts of the room that stood still become one 3D room. The people in the clip are found in each frame and kept frame by frame, standing where they were at that moment. It takes about three minutes and the clip's square says where it is while it works.

When it's ready the clip's first key is 4D. Press it and the clip opens in 3D. Play runs it, or drag the slider. Now shows the moment you're on. Trail shows the last second and a half of moments fading behind it. All shows every moment at once. As filmed puts you in the phone's own camera as it moved; drag anywhere to look around on your own.

The first version made walls look like they were moving, because the depth from one stretch of the clip didn't line up with the next, by up to 8%. Two changes fixed it: every stretch is now lined up against the same set of frames from across the whole clip, and the people are found in the picture itself instead of guessed from the geometry. On your RoadGuard lift clips the two workers come out clean and nothing else is marked as moving.

Not done yet: 360 walks (their frames are spheres, that's next), smoother moments (they're points now, not the soft blobs Bilawal's are), and a lift going up stays part of the room because only people, vehicles and animals count as moving for now. Nothing here has been tried on your Razr yet.

Also tonight, on your word: the 174 GB of old July to September copies on the shop PC's D: drive are cleared. The 23 original recordings (your raw 360 walks, the phone clips and the old phone scans) are kept in D:/splat/kept-old-walks. Everything deleted was rebuildable scratch.

Also fixed tonight, from the reviewer: a photo you share by link now goes out as a fresh copy with no location, time or camera details in it. Before, the link could hand out the original file, and a photo from your gallery can carry exactly where it was taken. Your Claude also makes a share link only when you ask for one now, and every link you make is listed on Where your record went. A shared video can still carry where it was filmed if your phone wrote that into the file — the privacy page says so, and fixing it is next.

Now the address line under a job's name is its own key: press it and the field opens right there, with "Change" or "Add address" beside it. On the Record, a job's ⋯ has Change the address, which takes you to that same field.

And when the as-you-type list finds nothing, Enter or Search asks every geocoder we have once, so an address the first one doesn't know is still findable. It still only saves an address picked from the list — never free text.

The Jobs page now prints each job's address under its name, and a pin key beside Rename sets it in place: one field, the real addresses it finds as he types, and a press files one. Like every address in the app it is elected from the list, never free text.

Model my day stands anything with no location of its own at its job's address — only on a job whose day has nothing placed of its own (where any capture of that day stands on a real fix, the work is there and a stray shot is still said to be without a location), never the Unfiled pile, never a link or a task. Its card has a dashed edge and says "At the job's address · no fix of its own", its circle is 40 m wide, and the day's line counts them. Nothing is written back to the photo.

A group's ⋯ now carries Move this group to another job (File this group to a job, on Unfiled). The phone asks the groups route for EVERY item in the group by id — never only the ones the page has read — and moves them in the one move, so the group goes with them whole, its name and its 3D kept.

It's Auto by default, so drag the window narrow and it turns back into the phone layout. If you want to override it, the You page has a new Layout row under This phone: Auto · Phone · Desktop. Phone keeps the narrow column on your computer; Desktop gives a phone or tablet the wide Record. The choice is kept on that device only, and it's set before the page draws, so the wrong layout never flashes first.

Nothing about what's on the Record changed — same days, same groups, same order. Tested in a headless browser at desktop and phone sizes; it hasn't been tried on your own computer or Razr yet.

The Web app code opens Tradesman's download page in their browser, where they add it to the home screen and make an account. The Android app code is the one permanent download link, so a code you show or print today still installs the newest build after every update. Copy the link instead sits under it for texting.

The codes are always black on white, even in dark mode, because phone cameras read dark on light. Both were checked by decoding them with a separate QR reader — they come back as the exact links.

A photo's ⋯ menu now has Make a 3D drawing. A 3D drawing is made from a group's photos, so: if the photo is in a group, one press asks the shop PC to measure that group; if the group already has a 3D, the row opens it; if the photo is in no group, the Group sheet opens with its 3D switch on — pick a group or name a new one and the 3D is asked in the same press. A 360 photo or an imagined frame never gets the row.

On a phone with a share sheet it opens the sheet so you can send it straight to a text or an email. Otherwise it copies the link and says so. Stop sharing on the job still closes every link to it.

Your Claude makes these. Ask it for a photo by its short ID (like #HH) and it gets a share link along with everything else about that item, and it puts that link in the email or text you're writing instead of the app's own link, which needs your sign-in.

Each link stays open for 30 days. Stop sharing on the job closes every link to it at once, and deleting the item closes its link too. A task, a saved link, a 360 walk or an imagined frame is never shared this way. The page tells search engines not to list it.

Privacy says it plainly, and so does the page Claude shows you before you connect it. Faces are still not blurred, so look at a photo before you send it.

So a photo or clip that isn't in a group now shows the group it was most likely taken with, on one line at its foot: the group's name and a question mark. It goes by how many minutes apart the photo was from the group's nearest photo, then by how far away. It only shows when one group clearly wins. On your day it got 38 of 42 right, and your two photos land on the right poles. Open the photo and the card says why, for example "2 min apart · about 15 ft away". Add puts it in the group, and ✕ means not this one and is remembered. Nothing moves on its own.

Holding a photo to pick it used to open every folded group on the day, so the whole day jumped under your thumb. Now nothing opens when you start picking, and the photo you held stays exactly where it was. Press a folded group to open it and pick from it. Select all reaches inside folded groups too, and their square shows how many you picked.

The Group sheet now starts with your groups, each with its picture. The group the photo was likely taken with comes first, then two more, and "All groups" shows the rest. Naming a new group comes after. The 3D switch only appears when you press 3D.

Opening a folded group no longer reshuffles the day. Its square stays where it is, and the group opens right under that row with a little notch pointing at it. Every photo after it stays in its column. Press the square again, or Show less, to fold it back.

The rest of the scroll audit is done too. In Measure, the wire and conduit answer comes first. Once your Claude is connected, the Connect page is your Claude's page. The X5 card puts its form first. Sign-up keeps its button above the keyboard. Privacy and Get the app are shorter, and Privacy still lists everyone who touches your record.

The shop PC now cleans up its own copies of deleted records on D:, so deleting an account clears them within a day. It only removes copies of records it saw while they existed. That leaves 174 GB of old walks and shifts from July to early September, some of your early raw recordings among them. Those stay until you tell me what to do with them.

Your Claude now sees each task's words in a day. Before, every task printed as its time and "PAPER". It also sees the crew line a task sits under, and can add a task under a line.

Three fixes to the task photo reader, from the reviewer. A photo you read tasks from now goes as a clean copy, its pixels only, so its location and time never reach the reader. A screenshot of a crew chat gives only your plan: other people's messages are left out, and the box says how many. Privacy now says plainly that pressing Send hands the day's tasks to WhatsApp, which is Meta, and that they reach a chat only when you send them there.

You asked about a free model on the shop PC for when Claude can't draw. I tested an open one that runs on the shop PC's graphics card. It finds 95% of the things Claude's drawings show, in about 10 seconds a photo, and it costs nothing. But it gets about a third of the names wrong and makes up text it can't read. I built three versions of a free sketch with it and compared each to your real photos. None was good enough to put in your Record, so none of them shipped. Your 3D isn't lost when your plan hits its limit: the shop PC waits and draws it when the limit resets, and every kit is kept so it can be drawn later.

To add a task, type it and press Enter. Or paste a whole list. If it has bullets, like your WhatsApp plan, each bullet becomes a task under the line above it, so your crews stay together. If it doesn't, each line becomes a task. The microphone button turns everything you say into tasks, one per pause. The picture button reads a list off a photo or a screenshot and puts the words in the box, so you can check them before you add them. Today's card can also put tasks on Tomorrow, and then Tomorrow gets its own card.

A task only goes on a job when its words name the job. "Potomac" goes to Potomac Woods. Otherwise it's just that day's task, and the app never creates a job for it. Send gives WhatsApp the day's open tasks, with each crew above its tasks, and you send it. If there's no signal, tasks wait on your phone and go through once you have it.

Reading a photo is the one part that reaches outside the app. That read runs once on Tradesman's account with Anthropic, costs about a cent, isn't kept, and shows on Where your record went.

When today's card has no tasks yet, it's just the box to type in, so your photos start higher on the screen. If you type a task, don't press Enter, and then speak or add a photo, what you typed still counts as a task. To make a line a heading instead, end it with a colon, like "Alex and Nathan at 8:". And since Send hands your tasks to WhatsApp, WhatsApp is now listed on Where your record went and on the privacy page.

When you file a line like "MTS roadblocks" under a job by hand, it remembers MTS, so your next plan puts it on that job by itself. After noon a new plan is for tomorrow. Save & send opens WhatsApp with your words already in it, so you still send it to the crew yourself. Nothing reads your plan but the app's own code — no AI call.

The plan shows at the top of its day as you wrote it: each crew's line, then its tasks, each with a ring to tick. Tick one off there and it's ticked everywhere, including in your Claude's list of open tasks. A task still open after its day shows as late on today's list until it's done. On a past day, "How did it go?" asks your own Claude to compare the plan with what the record shows got done. Edit changes the plan and its tasks follow, and the ones you already ticked stay ticked.

Your plan from earlier is not in your record — you said not to file that one. Paste it in yourself if you want it there.

I also measured how far you have to scroll on 44 screens and fixed the ones you use every day. Today's photo sets now fold into one square each once they're 45 minutes old, the same way past days do. Whatever you're still shooting stays open. A task due tomorrow now sits on today's list instead of adding a whole "Tomorrow" section above Today. A photo's details open with your note first. The Jobs page tucks jobs you haven't worked in a month under one "Older" line. What's new shows each entry's first paragraph. Appearance on the You page is one row.

While testing, I found and fixed a bug: a note you wrote with no signal sometimes filed when you reopened the app but didn't show on the Record until the next refresh. It now shows as soon as it lands.

The reviewer's latest notes on deleting your account are fixed too. The delete screen now says what it doesn't remove: the working copies on Tradesman's own computer, which aren't cleared automatically yet (ask and they'll be cleared), and files on other sites that your record only linked to. When it finishes, it tells you how many files were removed and how many it couldn't touch. It also checks the database first: if anything would stop the account itself from being deleted, it stops before removing a single file and tells you why. Saving just the index now warns that anyone with that file can open every photo in it, and the index's date uses your own time zone.

Download your record saves everything you filed: every photo and clip as it was sent, every 360 walk, your 3D drawings, and an index.html that opens in any browser with no app and no account. Files are sorted by job and day, and named so you can find them in a year. On a computer it saves into a folder you pick using Chrome or Edge. In the Android app it saves to Documents. If the connection drops, pressing it again picks up where it stopped. The walks are big, so they're a switch, off by default on the phone.

Delete your account removes everything on it, including the files in our storage, and then the account itself. It asks right in the page, offers to download your record first, and only goes ahead once you type your email. It never touches anyone else's record: it only removes things tied to your own jobs and account. A large record takes a few passes, and if it stops halfway your account is still there and you can press it again.

The privacy page now also lists two outside services the log showed we had missed. On Android, your phone's speech service, which is Google's, hears a voice note while you say it. Your browser's push service delivers the camera's notifications, sealed so it can't read them.

Signing out now also removes your saved X5 cameras and their Wi-Fi passwords, a note you were halfway through typing, and the phone's copy of your photos, so the next person on that phone can't get into your camera. If a photo is still being saved, Sign out waits until it's done. If a 360 walk is still recording, it tells you first. The privacy page also used to say the camera follows no one. That was true of Tradesman's computer but not of your phone, which can keep a person framed on your screen while you watch live. The page now says that, and that nothing about them is saved.

You is your account. It shows your name (tap the pencil to change it), your email, and how much is on your record: photos, clips, 360 walks and notes, how many jobs, and the month you started. It also has your Claude, light or dark for this phone, the Android app and whether an update is waiting, Add to Home Screen, How Tradesman works, What's new, Change your password and Sign out.

Sign out only signs out this phone, never your other phones. If photos are still waiting to send, it tells you how many first and lets you wait for them, because signing out deletes them. It also wipes your photos and jobs off this phone and stops this phone getting your notifications, so whoever signs in next sees nothing of yours.

The ⋯ in the top corner is gone. A job's own options (Ask Claude, Share, Rename, Delete) are now on the ⋯ beside the job's name when you're looking at that job. New job is on the Jobs page, and Connect your Claude and Add to Home Screen are on You.

If you're not signed in, the app now opens on a welcome page instead of the bare words "Sign in first." It says what Tradesman is in one line, gives three reasons in a few words, and has two buttons: Make your account and Sign in. On a small phone the buttons stay on the screen.

There's a new page, Your record is yours, that says in plain words what we promised: only you see your record, nothing trains an AI on it, your own Claude reads it on your own plan, nobody is tracked, and here is every outside company that touches it. It also lists what isn't done yet, like faces not being blurred. How it works, What's new and Get the app now look like the rest of the app and link to each other.

To make that promise true, the 360 camera no longer tracks the people on site unless a shift asks for it, and nothing asks yet. The page Claude shows when you connect it said Claude was read-only, which hasn't been true since it learned to add notes and tasks. It now says exactly what Claude can see, what it can add when you ask, and what it can never do.

Forgot password, page not found, something went wrong, no signal, the 360 video page when you're signed out, and the sign-in page's way back now all look like Tradesman instead of three different older apps.

All eleven of your existing drawings already have it (three groups, three clips, five walks). Every drawing is unchanged, the same parts and the same notes, and each one was opened and checked before it was saved.

Two of those drawings had named something in them "strip" or "lens", the same words the new page uses. Before saving anything, that broke them in testing. The page now keeps its own names to itself, so a drawing can name its things anything.

The Flashlight no longer shows a paragraph explaining what it isn't. It explains the camera permission only until the light works, and shows the warning about flashing lights only in the flashing modes.

The bottom of the Record no longer shows "read in 0.4 s" in tiny code font. That timing now appears only when loading took two seconds or more, which is when it's worth a look.

Under the row is a strip of photos, like a gallery. On the whole site you see every place; tap one to go there. At a place you see every photo, clip and note taken there; tap one to see it large. Places you got to later that day are faded, so stepping through plays your day back. If your Claude has laid out a plan, it's the last stop, with each proposed item one tap away.

Tap the place's name to see what Claude drew there. 3D | Above at the top switches how you look at the site, and it stays that way as you step. Inside the app the page no longer repeats its own title and its 'drawn by Claude' line: the app's bar above it already says both.

Model my day works the same way now. Play the day, the fit button and the big card are gone. Back and forward step photo to photo in the order taken, the strip underneath is your whole day with the whole site first, and tapping the card opens the photo.

Your Herndon site already has the new layout. Its drawing is untouched: same 23 parts, same notes.

Groups you never named already showed a name read off their photos in the app, like "Siemens panelboard". Your Claude couldn't see those names, so "pull the Siemens panelboard group" went nowhere. Now it sees the same names the app shows, worked out the same way for each job, and it says them as the photos' names, never as yours. In the app, those names now start with ≈ so you can always tell them apart from names you gave.

When your Claude reads a day, each item now says the street it was taken on and the numbers read off it, like a permit or a serial, up to a size limit so the answer never gets too long. A day like Aug 26 at Redland Road now carries the permit number right in the day read.

Your job's street map for the 3D site rebuild no longer goes to a backup map server run by a Russian company. That request carries where you worked that day, which isn't something a county or a camera vendor would want shared. If the main map server is busy, the rebuild waits and tries again, or builds without the map.

Now it searches everything Tradesman already knows about each item. Searching "redland" used to find 6 things; it finds 50. "redland permit" used to find nothing; it now finds your close-out task, the permit photo, and the drawing. Under each result it shows the street and the exact words it matched, like the permit number itself, so your Claude reads the answer instead of guessing. Ask for one item by its short ID, like #QQ, and it hands back everything written about it.

It also fixes a trap that was days away. The database hands back at most 1,000 rows per request, and your record was at 954. Past that, your oldest work, including the August permit photos, would have silently dropped out of your Claude's search, its day reads and its list of jobs. It now reads every row, a page at a time.

Nothing new costs money: every photo was already read when you uploaded it. The search box inside the app is separate and still only searches notes, streets and code; this fix is for your Claude.

Now a day that's over reads at a glance. Each group, and each set you shot in one go, is one square in the day's grid, in the order it happened. The square shows its best photo, its name, and how many things are in it. Press it and the group opens right there. Show less folds it back. Your Herndon day went from 4.7 screens to 1.4.

A group you never named now names itself from its own photos. Tradesman already reads every photo and writes down the one thing it shows. The group takes the name most of its photos agree on: Siemens panelboard, Elster digital electric meter, Key lock box, Exposed wiring splices, Outdoor junction box. The photo that name came from becomes its cover. No AI is asked for this, nothing new is stored, and your own name always wins. A name that came from the photos is drawn lighter so you can tell it's a guess. The group keeps that one name everywhere: on every day it's on, when you open it on its own, in a photo's details, in search, and in the Group sheet when you add to it.

To give a group your own name, open it, press its ⋯ and pick Name this group. The box starts with the name it has now, already selected, so you can just type over it. Clear the name and the group goes back to the one its photos give it.

Some things never fold, because folding them would hide what you're working on. Today stays fully open while you're working it. Everything opens while you're selecting, searching, or looking at one group on its own. A group you just made or added to stays open so you can see what went where. A group with a photo still sending stays open so "waiting for signal" is never hidden.

The + that added to a group is now a small key in the group's header, next to its ⋯. It used to be a full square at the end of every group. It opens the same card as before: take photos, add from your phone, a note, a voice note or a link.

What's not done yet: the day still shows newest first. Two groups can come out with the same name, like your two light pole bases, and Name this group is how you tell them apart. A photo that hasn't been read yet can't help name its group until the read finishes. None of this has been on your Razr yet.

Your Claude never guesses coordinates. It names where each thing goes by what's already on the site: one of the map's poles (n5), a building's wall nearest one of your spots, a spot itself, a point on the site, or another item of the plan. The code then works out the point, refuses in plain words anything that doesn't resolve (a pole the map doesn't have, a point off the site), and measures every run along the map. So when it tells you the feed is 110 m (360 ft), that number is arithmetic on the map, not a guess. It also says what the number is: level ground, before the drops, the bends and the makeup. It never sizes a wire or a breaker from it.

Lights, cabinets and chargers placed at a wall mount on it, facing out. A light placed at a pole hangs on it. A handhole next to a pole sits in the ground beside it. Anything else placed at a wall stands just outside the building, never inside it.

On the page, every item is a blue tag (P1, P2…) with its own card: what it is, that it's proposed, where it was placed, and for a run its length along the map with that caveat. A Plan view frames the whole build, and Hide plan puts it away. Removals are red. The plan is drawn over the site: a contactor on the far wall of a building still shows its tag, and on a wide screen a name never sits on its own tag. Both of those were wrong when I first looked at a plan on your real Herndon site, and both are fixed.

The plan is stored on the ground in latitude and longitude, not in the drawing's coordinates. If the site is rebuilt later around a new middle, the plan stays where it was on the real ground. When you open the site, the app puts the plan into the page as plain data, which can't run as code, so the page keeps the same lockdown as before. For ten minutes after you press Plan a build, the open page picks up a new plan from your Claude by itself.

Your Claude can also find a site on its own now: tradesman_day lists the day's rebuilt sites by id, and it can open a site's overview map, its contact sheets, and any capture's photo by its short id (#KZ).

Tested on your real Herndon kit, with your Claude's side played through the real connector code and nothing written to your record: a plan to re-feed the lot pole lights from a new lighting contactor beside the Siemens panel, with handholes at the four poles and two underground runs of about 110 m and 101 m. Playing it caught two bugs, now fixed: a handhole next to a pole was being called pole-mounted, and something placed at a wall could have landed inside the building.

Your Herndon page is now rev 2: the same drawing, byte for byte, with the page around it brought up to date, so the plan layer is on it. That also fixed a renaming slip that had made the page ignore your phone's reduced-motion setting. It has no plan yet; the first one is yours to make.

Not done yet: none of this has been tried on your Razr. Your own Claude hasn't laid out a plan in claude.ai yet. The ground is still flat, building heights are still guesses where the map has none, and a site still covers one day.

THESIS.md now says what Tradesman believes: the record belongs to the worker, nothing is disguised, nobody trains on a record without the owner saying yes, people who did not agree are not data, and a master's work teaches the next apprentice first. The open questions are listed instead of pretended away, the biggest being who owns jobsite photos on a company job.

docs/human-first-brief.md is the brief for Claude Code. It asks for a one-page audit of the app against the new thesis before anything is built: what the first screen should say, what to cut and keep, and the order for exporting the whole record, a plain-words page of where your data went, a not-for-training license stamp, no tracking without a yes, and account deletion. No code changed.

Why not just use Google's 3D ground? Google's terms let us show it live, but never keep it or build anything from it. So the rebuilt site uses OpenStreetMap instead: building footprints raised to their heights, roads at their widths, parking lots, grass, and the map's own street lamps, utility poles, signals, transformers, cabinets and trees. Google's ground stays where it is, as the live view behind the key.

Your captures become spots: the places you stood to capture something. One of your groups stays together. So does one opening of the camera. Anything else within a few metres joins too, but two poles a street apart stay two spots. For each spot, the shop PC also lists what the map has within reach: the lamp or pole a few metres away, the building wall beside it, the nearest road. A phone's fix is where you stood, not where the thing is, so the map's own pole is often the honest place to draw it.

Then the same free drawer that draws your walks and photo groups (Claude Code on your own plan, on the shop PC) reads every spot's photos, decides what each one is, and draws it where it belongs. It places a lot light on the map's own lamp, with its handhole open and the splices drawn. It puts a panel on the building's wall and tags each meter by the number it read off the face. Every photo, clip and note is attached at its spot. Tap a spot to see everything you captured there, and tap a picture to see it large.

Stolen from Bilawal Sidhu's 'God's Eye View of Time', the video you sent. First, a scrubber and Play: drag through the day and the spots light up in the order you worked them, or press Play and it flies you from spot to spot. Second, Stand here: open a photo and the view drops to where you stood, with your photo in a window you can fade against the drawing behind it. Your photo in the frame, the site around it.

Measured on your Herndon day (51 captures, 70 m across): the shop PC built the site's kit in 12.5 seconds, with 46 buildings, 151 road pieces, 73 mapped points and 19 spots. Your plan drew it in 16.5 minutes, at no cost: 26 parts, including the lot poles on the map's own lamps, the Siemens panel, and the meter bank on the brick back wall with its enclosures, disconnect, wallpacks and the broken conduit at grade. Then it ran live on your record: queued at 12:13, the shop PC had the new code at 12:19, and the site's kit was ready 38 seconds later. Your plan drew it, but the app refused the first save because Claude's notes ran past the 2,000-character limit. Claude shortened them, and then the drawer wrongly rejected the fix because the page itself hadn't changed. Fixed the same hour: either file changing now counts as a fix, and the brief states the limit. Your rebuilt Herndon site (23 parts) is live: open the day's model and press Open the rebuilt site.

Not done, said plainly: the ground is drawn flat. Building heights are guesses wherever the map has none (at Herndon, that's every building). A site is one day's, so seeing the same place across days is the next step. Your own Claude can't redraw a site through the connector yet. And none of it has met your Razr.

Dragging the model now drags it, even when your finger starts on a photo card. With forty cards on a busy day, most drags started on a card and did nothing. On your phone they also scrolled the Record behind it, out of the place you'd left it. A quick tap on a card still opens that card.

That scroll bug was bigger than the model. Since late September, the lock that's supposed to hold the page still behind every full-screen tool and the photo viewer had been doing nothing. Measured: a mouse wheel moved the page 600 px with the lock on. One small shared lock makes it real everywhere, and your place in the Record is exactly where you left it when you come back.

Smaller fixes on the model. A pin you fly to before its ground is known no longer puts the camera underground. When Google's 3D ground can't load, the flat satellite view takes over cleanly. The credit line names Google Maps and shows the satellite picture's own credit corners. The satellite picture is never kept in the phone's cache (Google's terms forbid it). Every request for the 3D ground goes on the ledger, even one you close after two seconds. Opening a photo's group from the model now shows you the group instead of leaving it hidden behind the model. And a photo taken with the front camera now faces the right way on the map.

The Tape's calibration was claiming accuracy it didn't have. A 10 ft walk is about four steps, so one miscounted step is a 25% error, and that error rode into every measurement after it. You now calibrate on 50, 75 or 100 ft. A walk under sixteen steps is refused, with the reason. The ± never claims better than one step in all the steps you've walked. And one earlier walk can no longer veto a new one, because the earlier one might be the bad one: two walks that disagree are both kept, and a third settles which was off.

Closing the Tape mid-measurement now stops the phone's camera tracker. Before, it kept running in your pocket.

The Compass no longer jumps when you tilt the phone past 45° with your wrist turned. It sticks with the edge you're aiming with, holds that edge for the whole three-second bearing, and tells you when you're holding it at an in-between angle. A bearing saved in Magnetic now keeps the true bearing too, and every saved bearing records when you took it, not when you pressed Save.

Two precision fixes. The Flashlight's SOS speed check now measures against the dot length SOS actually uses. The Ruler's card and coin outlines now show exactly where to line up: the grey shape is the true size and the blue line sits just outside it. Before, a thick line was centred on the edge, which left a third of a millimetre of doubt about which side to match.

Cleanup: deleted the old Stand here 3D viewer. Nothing had opened it since the day model replaced it.

A clip waiting for signal now shows on the Record like a waiting photo, playing its own first frame. The bottom line says what's waiting by kind ("2 photos · 1 clip waiting for signal") instead of calling everything a photo.

You can now edit a task's words and due date from its page; it moves to its new day as soon as you save. A group opened on its own now ends with the same + as on the full Record. And the same photo picked twice in one Add now goes up once, and the app tells you.

I had three independent reviews read everything shipped last night, and fixed what they found. Your Claude's search was treating trade words like "pole7", "480v" and "12awg" as short IDs and finding nothing; now an ID only counts when you write it with its # ("#K7"). A link or task found by its ID now prints properly instead of as an empty note. Answers no longer let the model copy a #K7 next to a citation, where a wrong one would send you to the wrong photo; the proof under each answer carries the right ID instead. And photos taken together no longer have one photo's note read as being about all of them.

The update hold got smarter too. It now waits for work that only exists in the phone's memory: a photo still being processed, a clip still recording or saving, files you just picked. Before, an update could land the moment you hit the power button and lose that clip. A search box no longer holds updates, and the two-hour limit never reloads over a field you're typing in.

I also ran the whole test suite after tonight's changes: 970 passed, none failed. The 10 skipped are the by-hand checks that call Google's real 3D ground.

Now when your Claude reads a day, the photos you shot in one go say so: "taken together: set 2 · 3 items". It reads the close-up and the wide shot as one set, and a note you wrote on one of them as being about all of them.

The drawings still open as their own pages, the way they always have. They aren't merged into Google's 3D ground, because each one is drawn in its own room-sized frame with nothing tying it to the earth.

Now any photo whose group has a 3D drawing wears a small white cube on its card in the day model, so you can see from the whole site where your drawings are. Tap the card and it has a "3D drawing" row with the drawing's name; one more tap opens the drawing right over the site, and Back puts you back on the 3D ground where you were. Walks and clips with drawings aren't on the site yet; this is your photo groups.

Now the update waits for you. Words you've typed and not saved hold it, even if you put the phone in your pocket. A photo, the day model, a tool or a sheet open on your screen holds it until you lock the phone or switch apps, and then it lands with nothing lost. When you're just looking at your Record, it lands right away like before, so your phone still never falls behind.

On a phone it now lets go of map pieces you've moved away from much sooner, so it stays under about 140 MB. I ran it again as a phone and the 3D and top-down views look the same: what's in front of you is drawn just as sharp. Only what's behind you is dropped earlier, and it streams back if you turn around.

Now every line your Claude reads of a day or a search names the item's short ID, so it can point you at "#K7" and you find it on your phone in a second. Ask it for one by name ("#K7", "k7", even an O typed for a zero) and it pulls exactly that item, however old, and only ever from your own jobs. Items from before the IDs, and anything without one, read exactly as they did.

Now the 14 seconds only count while the model is actually on your screen. Open it, switch away, come back, and it's still waiting for the 3D ground, which streams in the moment you're looking. On your phone this matters too: open the model and put the phone in your pocket, and it won't have given up on the 3D by the time you take it back out.

Every photo is now a card showing the picture itself, standing on the ground with a pointer whose tip is where you stood. Cards that crowd together become one stack with a count, so the restaurant reads as a handful of stacks, not 48 overlapping chips. Tap a stack and the camera zooms in until the photos separate. Where several were taken at the same spot, which no zoom can separate, the card opens on that spot and lets you step through each one.

North is up in both views. The 3D view opens a quarter closer so the work stands big in the middle, and the photo in the card is bigger. The numbers stay on the timeline strip and the card, never on the ground.

The ground is Google's photorealistic 3D tiles, streamed live and never saved, with Google's own credit printed under it. Where Google has no 3D, or off the deployed app, the satellite still lies flat in its place and the glass says so. Every pin is placed through Google's own model of the earth, not a guess at which way is north — I checked it on the Washington Monument's lawn: a pin 120 m north stood straight above, one 120 m east stood to the right, at one scale, on the grass. A pin stands on the lowest of seven readings of the ground around its fix, so a photo taken beside a pole stands on the ground, not on top of the pole.

Your photos from Tradesman's camera now record which way the camera faced, not just where you stood — made true north from the magnetic reading, and marked rough when the needle was swinging near steel. The model draws that as a little wedge on the ground, and the viewer's Info says it in words ("Facing NE · 47° true"). Photos picked from your library don't carry it yet.

The Compass is back in Tools, and it takes a bearing instead of making you squint at a jittering needle: hold still for three seconds and it averages every reading, then gives you the bearing the way a plan writes it ("S 79° W"), the way back, and how much the needle swung. Hold it and it tells you which way to turn to stay on the line — for a trench, a conduit run, the line to a pole. Save writes it as a note in both true and magnetic north, with where you stood, and it never gets lost with no signal.

The Flashlight now turns itself off after a time you pick, so it isn't dead in your pocket next time. It can mark a spot for an hour with one short flash every few seconds, or send your own words in real Morse to the man on the roof. It times the camera and tells you whether it's really keeping up with the flash rate you asked for, and Off is now off at once even on a slow phone.

The Tape now reads to the inch or the centimetre, and it averages your last few calibration walks and tells you your own spread, instead of trusting one rushed walk. It also does the counter math for you: run, drops, makeup at each box, slack, times conductors, plus the EMT sticks and couplings — every line printed so you can check it, every rounding up so you don't buy short. It counts length only; it never tells you what size wire to use.

The Ruler grew a caliper. Lay a wire, a screw or a bit on the glass between two jaws and it reads the gap to a thirty-second of an inch and a tenth of a millimetre, then names the nearest wire gauge, screw and drill bit and how far off each is — or says nothing standard is that close. It's for bare solid copper and says so. With no bank card handy, a quarter, nickel, penny or dime can calibrate the screen now.

Said plainly: none of this has met your Razr yet. The 3D ground on the phone, the real compass and flash rate, the pedometer and your screen's true size are all proven in a browser against stand-ins, and checked against Google's real ground on a desktop. Your next day on site is the real test.

Every item on your Record now has a short ID the database gives it the moment it is saved: #K7, #3M, #Q3. It uses only digits and capital letters with no I, L, O or U, so nothing is misread, said over a radio or typed with gloves. Every item you have today has two characters, and the first 1,024 ever saved will too. You see it at the top of the viewer ("#K7 · Herndon Pkwy Restaurant"), on every square while you are selecting, and in the Group sheet, and search finds "#K7".

A photo or clip you add from your phone now carries a fingerprint of the original file. If that exact file is already on your Record, on any job, the server hands back the one it has before storing anything. No copy is made, and the photo is never pulled out of the group it is in. The app tells you: "#Q3 is already in Pole 5 — not added twice."

Anything can go into a group now. A note, a link or a task has a Group button on its own page, and a photo has one in its ⋯ menu. The Group sheet comes up over what you are looking at, says which item it is and where it is now, and lets you take it out of its group. The + in every group can now write a note, record a voice note or save a link straight into that group.

Not done yet: your Claude connector does not use the IDs. Photos added before tonight have no fingerprint, so adding an old one again is not caught. And none of this has been tried on your Razr yet.

Take photos opens the camera on that group. The top of the camera shows the group's name instead of the job, and every photo and clip you take goes straight into the group.

Add from your phone opens your photos. Pick as many as you want and they go into the group with nothing to fill in, each on the day it was taken. While they send, they already sit on the group's tray, so you can see where they're going.

Your Claude reads it the same way: a grouped photo's line now says group: "Standard sauna, removing" (or "group (no name)"), a day reads in plain time order, and the before/after filter is gone. The trade-off, said plainly: Claude is no longer told which photos show the job before and which after. If that matters for a group, put it in the name — "Panel B, before".

You also said the light border line was ugly. A group and a set of photos taken together now sit on a soft grey tray with no line at all — the squares on it line up with the rest of the grid, and it works in dark mode too.

The photos you took with the in-app camera since Sep 27 had lost their "taken together" stamp. They were stamped after the fact, so 52 photos in 20 camera sessions are on their trays now. Your older groups keep their old tag in the database, unread, in case you ever want the words back — nothing was erased.

Picking several photos from your library in one Upload works the same way: they come in outlined together. One photo on its own gets no outline, since a box around a single square says nothing.

This isn't new data. The old camera used to mark which shots belonged to one session, and about 360 of your photos from August to mid-September still carry that mark. The new camera stopped writing it in late September. It writes it again now, and your older sessions get their outlines too.

A group you made yourself (Existing or New work) keeps its own outline with its name on top. The plain outline never doubles up inside one.

One bug fixed on the way: with slow signal on site, photos that finished uploading after you pressed Done kept saying "sending" until something else refreshed the page. That's what makes you think a photo didn't go. Now they flip to done within a couple of seconds.

Once you've asked for it, the 3D shows up as one square in the group, the first square. It says where it is in plain words: waiting for the shop PC, measuring your photos, Claude is drawing it. When it's done it shows the drawing's own title, and you tap it to open. There's nothing to chase and nothing to press twice.

Today's tasks no longer take over the screen. They rest as one line, like "Tasks · 7 open · 2 late". Tap it and the list opens right there, with Select beside it. The phone remembers whether you like them open or folded.

While testing this I found a real crash. With a day's ⋯ menu open, pressing on the day's date killed the page outright. That's been true of the day menu since September 29th. It came from a performance trick that lets the phone skip drawing days you can't see. The day switched that trick off while its menu was open, and switching it under a finger crashed the engine. The menus now float in their own layer, so the trick never has to switch. A test presses exactly there on every run, so it can't come back.

The ring on the left of a row ticks it done right there; tap the rest of the row and it opens as its own page like before (Done, Move, Delete).

To clear several at once: tap Select at the top of the list (or long-press a row), pick the ones you want — or Select all — and press Delete. It asks once, then they all go in a single request. If there's no signal it keeps your picks and says so instead of half-deleting.

Tasks can't be dragged into Existing / New work groups — group select still only picks photos, clips, notes and links.

Job-site photos are not a video: they jump between spots and often do not overlap. So the shop PC sorts them into areas — the photos that see the same place — and measures each area on its own. The drawing shows every area as its own island, side by side, and says plainly that the islands are not measured against each other. For one connected model of a whole space, walk it with the X5, or take photos that each overlap the last.

Measured on your own photos: the WELLFIT set (16 photos) became a kit in about two and a half minutes, and RoadGuard (30 photos) in under four. The WELLFIT set was drawn in 18 minutes: the sauna, the conduit drop into the twist-lock, the inlet box on the cedar wall, the open panel, Panel A over the Acme transformer, and both nameplates. Seen from each photo's own camera, the drawing matches the photo.

A photo drawing opens on all the spots at once, each with one numbered marker, and the bar at the bottom has a key per spot ("2 · Sauna") that flies straight into it. Search now has "All 3D drawings", every drawn clip, walk and group on one shelf, because you could not find your drawings on their old days.

Security fix: four storage rules from the app's first weeks let anyone holding the app's public key list, download, overwrite or delete everything in the walk bucket — your walks, your 3D drawings, even the app update file. They are gone. Every upload the app and your X5 make goes through a one-time signed link the server hands out, and that still works: it was checked on the X5's exact upload path against production before and after.

Now a task is a square of the day's grid, like a note: its words, and at its foot a ring and where it stands — "Due today", "Due tomorrow", "Due Oct 9", or plain "Task" when it has no date. A task lives on its due day. An open task whose day has passed is LATE and rides Today in red ("Late · due Sep 29"), so nothing you owe gets buried under a week of photos. A done one stays on its own day, struck through with a filled check — the record of what got done.

Tap one and it opens as its own page, like a note: Done (or Reopen), Move, Delete. Done goes through the same tick your Claude's close_task uses, the square changes at once, and if the server says no it goes back and says so. Delete asks once, in place, and only ever deletes a task.

Search finds tasks by their words, and the count at the foot of the Record says how many there are.

Four of your older 360 walks were queued for you — the same as pressing "Make a 3D drawing" — and the shop PC measured each in 6.6 to 10.2 minutes and drew each in 15 to 19: the WattzLED shop twice, the WELLFIT electrical room (the switchboard, the wireway, the meter row; its measuring was trusted, so sizes show as approximate) and the Fortune Terrace breezeway (the wall packs, the dome cameras, the basement meter bank — drawn as two pieces, because the measuring never joined them, and it says so).

The first live drawings of the shop walks were correct but bare: the building and its electrical, with the shelving, the fridge, the desks, the machines and the flags left out on purpose. The drawer's instructions now name what makes a place recognizable, and both shop walks were redrawn with the same shop-PC drawer, checked against the real video frames from each camera, and saved as a second version. The first versions are still kept.

A new walk with nothing ahead of it goes from your Insta360 to a drawing in about 25 minutes, at no cost.

The brief now says it outright: the equipment and fittings, what they are mounted on, the runs between them, AND the big things that make the place recognizable at a glance — shelving and racks, machines, appliances, cabinets and panels, desks and benches, doors and their signs (plain blocks where their detail cannot be read). Someone who has stood there must know the place from the drawing. It still leaves out people, small loose tools and stock, and anything it cannot place — every part is still placed from the kit's anchors, never guessed.

Nothing else changed: the drawer's 29 tests pass, and the next drawing the shop PC makes uses it.

FREE, the way you asked. The drawing is made by Claude Code signed in to YOUR Claude plan — never an API key. The shop PC starts it with the API key stripped out of its environment, and it stops itself at the first line unless that line says it signed in with your plan. It runs with no connectors (your Gmail, Calendar and Drive never load), no shell, no web, and it can only write into its own folder. Each drawing is one line in the ledger with no prompt in it. Your plan after tonight's drawings: 45% of the five-hour window, 27% of the week.

ONLY YOURS. The shop PC draws only the walks and clips on your account. Anyone else's kit is measured and stops at 'Ready to draw' with the Draw it with Claude button — their own Claude does the drawing. The same drawer also draws your 3D phone clips, and once draws any of yours that were measured but never drawn — your WELLFIT clip is the one owed.

MEASURED on your real walks, through the shop PC's own code: the WattzLED shop (a 32-second walk) was ready to draw in 6.8 minutes and drawn in 19.4 — 26 minutes from Insta360 to drawing, 18 parts, from the exit door and the fridge to the overhead door and the flag. The 82-second Potomac Woods breezeway took longer: its first drawing ran past the 20-minute limit (a dropped connection threw away five minutes of thinking), so the shop PC waited and tried again thinking less hard, and drew it in 12 minutes. Your WELLFIT electrical room drew its two panels, the gutter and the meter where the photographs have them. Every drawing lined up with its own walk's photographs better than a wrong picture would — which is the only honest yardstick, because there is no absolute score.

WHAT THE REVIEW FIXED before this ships: a drawing that arrives while you are watching the walk on the sphere now waits behind a 'Drawing' key with one line saying it is in, instead of yanking the view away; going back to the walk starts its clock at 0:00 again; a phone video that came in as a walk is never offered a 3D drawing (only a 360 can be measured) and the door says why; the shop PC never saves over a drawing your own Claude made while it was still drawing; and a test now runs the whole chain on one record — a walk and a 3D clip from queued to measured to drawn — plus a plan limit that waits for the window and then draws.

NOT DONE, said plainly: none of this has run on the live shop PC yet — it goes live when it is pushed, and the very first thing to watch is Claude Code signing in from the box's own scheduled task, which it has never done. Older walks are not queued on their own: press Make a 3D drawing on one you want. Every walk so far had an untrusted scale, so the drawings print no sizes. And no drawing of a walk has been opened on your Razr yet.

Three new connector tools: tradesman_model_kit hands Claude the measurements and the sheets, tradesman_model_frame lets it look close at a label, and tradesman_save_drawing keeps the page on the capture — after a check that refuses anything that could reach outside the page. On the Record a 3D clip says 'Ready to draw' with one key, 'Draw it with Claude'; once drawn it opens on the drawing, under the app's own line: 'Drawn by Claude from your video — a diagram, not a scan · sizes approximate'.

Proved on this PC with his WELLFIT clip: measured and ready to draw 4 minutes 14 seconds after the shop PC picked it up, a 2.6 MB kit, and his real older 3D row re-measured in 14 seconds. A drawing was made from that kit exactly the way his Claude would, and opened in the app beside the clip's first frame — the box lands where the photo has it. A hostile drawing that tried 28 ways to steal or leave reached nothing; one that navigated itself away was taken down by the app at once.

Said plainly: none of it has met the Razr or the live shop PC yet (it starts when the shop PC's worker restarts), and no drawing has been made by his Claude inside claude.ai yet. A short, fast walk measures loosely — this one drifted after two seconds — and the drawing has to say so.

Now 3D is its own row in Capture, right under Photo ('A model you can walk around'), and it opens the camera already in 3D mode. 'Make a 3D model' stays on a clip's ⋯ as the quiet second door, for a clip shot before 3D existed.

Now one: the boot task that runs from its own checkout, restarts itself if it dies, and pulls every push on its own (it picked up the 3D builder six minutes after it shipped). The old copy is stopped and its supervisor disabled.

The reason the old guard never caught it: the kept worker runs as admin, and Windows answers a normal process's 'is the box taken?' with ACCESS DENIED rather than 'already exists'. The guard read that as 'can't tell, run anyway'. It now reads it as taken.

The shop PC builds it, no cloud and no API: the sharpest frames, MapAnything (the Apache weights) for the camera path and metric depth, a bundle adjustment that fixed the lens and tightened the path on every clip, then Brush trains the gaussians from that dense start. Measured on his own clips with every 8th frame held out: a first look in about 5–6 minutes (1.5M splats, 25 MB), then a sharper model about 7–8 minutes later (1.9M splats with full colour, 38 MB) that swaps in without moving your view.

In the Record the clip's square says where it is — waiting for the shop PC, building, 3D ready, failed — and it opens ON the model, starting from the video's own first camera: one finger orbits, two pinch and pan, a double-tap goes back, Video shows the clip. Any clip already on the record has 'Make a 3D model' in its ⋯. The model lives on the clip, so it keeps its job, its group and its Existing / New work tag.

AnySplat, the PRD's pick, was rejected at the source: its code is MIT but it loads Meta's VGGT-1B, which is non-commercial. gsplat MCMC was benched and lost (floaters, 20 minutes).

Said plainly: the model shows the space — fixtures, ductwork, where things hang — but thin wires smear and labels are not readable, so the photos stay the record for anything you need to read. Size is approximate (about 30% short in one check) and the app says 'not for measuring'. A long loop can drift and isn't closed yet. None of it has met the Razr.

Upload now asks one question before it files: which job, and what they show — none, Existing or New work — plus a label. A tagged batch lands as ONE group, even if half of it waits for signal. Every photo and clip keeps the time it was TAKEN (the photo's own EXIF clock, a video's own creation time), so last Tuesday's photos land on last Tuesday. And an old library photo no longer gets stamped with where you stand today.

Connect → Insta360 X-series: your saved cameras first (one tap connects), then an X5 card and an X6 card, each with where the Wi-Fi password lives on the camera, the three facts that trip people up, and the borrowed-camera note; Save keeps it as a named camera with its model.

The honest part: the camera SDK in the app knows the X3, X4 and X5 and has never heard of an X6, so the X6 card says it needs the next app update rather than promising a first-try connect. Supporting it is a newer Insta360 SDK and a new APK.

Found while checking: every X5 connect had written the camera's Wi-Fi password into the ledger. The phone now hides any password, secret or token before a row is written.

Hold any square in the Record for half a second and you're in select mode: tap more, or Select all on a day, then Group. Pick Existing (conditions before work) or New work (what's being installed), add a label if you like ('Standard sauna, removing'), or drop them into a group that's already on the job. Each tagged square wears a small E or N; a photo's Info says its tag. A group is one job's, and an item is in at most one group. Nothing is forced — untagged stays untagged.

Claude reads it through the connector: every item carries its tag and label, a day with tags comes back in EXISTING, NEW WORK and UNTAGGED sections, day and look take a tag filter, and a new tradesman_groups lists a job's groups. The rule is written into the tools: Existing is before, New work is what goes in, never one for the other. A job with no tags reads exactly as it did — pinned byte for byte.

Moves carry groups: a whole group moving goes with its items, a partly moved one lets them go, and deleting or merging a job carries every group to where its photos land. The review caught one real bug before it shipped — Supabase returns at most 1,000 rows, so a big group could be undercounted or a small one taken for empty; it now pages.

No model is called for any of this — tagging is his, reading is his own Claude. Next: tap a tag to see just that set, batch upload with a tag, and Connect's X5/X6 setup cards.

This phone is now the first thing in Connect, always 'Connected' with its own name (the Razr's model when Android says it). A press opens one small card: Camera, Microphone and Location, each On, Off (with where to turn it on) or Allow — and whether anything is still waiting to send. Inside the app it asks Android itself, not the web page, so the answer is the phone's.

The X5 screen is a camera now: the live 360 fills the glass, one red record key at the foot, the 360 photo beside it, Let Claude watch behind More. Record starts the walk right there — no trip to the old engine room — through the same recorder the old screen used, so nothing was built twice. While it rolls there is only a red clock and a stop key. The phone never stops a walk on a clock; a walk still rolling after a reload is picked back up. Nothing held? It files to Unfiled.

A finished walk plays inside the Record's viewer on the sphere — drag to look, play/pause and a scrubber — instead of opening a separate page. A walk still being stitched says so. The Connect row says Recording with a running clock while a walk rolls.

The box learned to wait out a 15-minute signal gap mid-walk (was 2) and to give long walks more time to join and stitch. Honest limits left: the phone's wake lock lapses after 4 hours with the screen off (a native fix, next APK), and a multi-hour stitch is too big for the box's one-shot upload. None of this has met a real X5 yet — only the fake one in the tests.

The belt that took a quarter of the screen is gone. In its place a floating dock: one round ink shutter in the middle (Capture), with Tools and Connect as small circles either side, their words under them so they read in the sun. Every option still stands up out of its key the way it did.

The top is one slim bar: Record | Jobs on the left, the dark switch, search and the menu on the right. The day heading is just the date and one quiet line of where; Ask Claude, Move this day and File this day live behind a small ⋯ on the day. The NEC numbers left the heading — they are still in each photo's Info and in search, which now suggests streets, notes and code before you type.

The grid got air: 4 px gaps, rounder corners, 28 px between days, no clocks on note squares. A spoken note now wears a mic and a typed one a page — Say it marks the note as spoken end to end, so it survives a retry with no signal. With no job held, Capture says where it files: 'Files to Unfiled · pick a job any time'.

The whole suite ran green twice (535 tests). It has only met a headless browser — his Razr is the real test.

Capture, Tools and Connect now raise their options straight up out of the key you pressed, the way a speed dial does. A second press, a tap outside or back closes it. The Note and Link fields say which job they are saving to before you save, and the job can be changed right there. Inside the app, Add to Home Screen is gone, so there is only ever one Tradesman icon.

The bar is now three keys: Capture, Tools, Connect. Capture lists Photo first and biggest, then Note, Voice, Upload and Link.

Tools holds Flashlight (steady, strobe, SOS, and a full white screen, back from before the cut), Measure (the wheel) and a new Ruler: a true-size ruler along the screen, inches to 1/16 on one edge and millimetres on the other, zero at the bottom edge of the glass. A phone cannot know its own screen size exactly, so it starts from the Razr+ 2024's published 413 pixels per inch and says so, and one calibration against any bank card (they are all 85.60 mm wide) makes it exact and is remembered.

The capture bar now shows every way work gets in: Photo, Note, Voice, Upload, Link, Insta360 (always there; it opens to linking one when none is linked), and Drone and Glasses greyed with Soon, which do nothing but say what is coming. The Record | Jobs tab lives in the bar too, under the search, so it never scrolls away. The search says what it searches: notes, streets, code.

Every note is one line until you tap it. A photo's note rides under its own photo as a one-line caption. A link is now a capture like a note, in the day you saved it, marked as a Claude artifact when it is one, opened in your browser. The Jobs page is just the list: open, rename, delete. Pins are gone.

Streets: opening a photo with no street looks it up right then. The overnight pass had been reading stale lists (a Next.js cache on routes that never read a cookie), which re-counted finished work and sent three paid photo batches that nothing will collect; both crons now read fresh, and the 27 photos still missing a street, most of them camera frames, are owed again.

Pinned to the job. His uncle built a Claude artifact, a 3D model of a transformer pad for the Buddhist temple job. Now a link like that can be pinned to its job: it sits in a Pinned row at the top of that job's Record, not tied to any day, a Claude artifact marked as one, anything else showing its website plainly. For safety: https only, the website is always shown, it opens in the phone's browser, never inside the app, and the app never loads what is behind it. His own Claude sees a job's pinned links through the connector.

Dark mode now has its own tiny sun and moon switch in the corner. It starts on whatever the phone is set to; once you press it, your choice sticks on this phone.

"No street on file" on days full of photos: every one of those photos had its GPS, but nothing turned GPS into a street since the Record replaced History. Now each photo gets its street once, after it has landed, so the shutter never waits. Photos within about 60 metres on the same day share one lookup, days list the streets you worked in order, and opening a photo shows its street plus its exact GPS point, which opens your phone's map. The 440 older photos with a fix get their streets over the next two nights.

Dark mode follows the phone's own setting: the Record, its viewer and menus, the jobs list, the connect page, sign in and the download page. The camera and the X5 screen were already dark. The Photo key flips to a light key on dark so it is still the one your eye finds.

Delete a job from the menu: it asks once, right there, and tells you where its photos and notes go. They are never erased with it; they move to Unfiled. Move a photo, a clip, a 360 or a note to another job or to Unfiled, and move a whole day with one press from its heading. Delete one photo or note, with one Delete it / Keep check first; a photo still waiting to upload is simply dropped from the phone. Edit any note you wrote, typed or spoken, and a photo's note; notes Claude or the camera wrote are marked and stay as they were.

The line at the bottom of the Record no longer hides under the buttons. And a photo waiting for signal for a job you have since deleted now lands in Unfiled instead of being stuck on the phone forever.

A clip is now saved on the phone the moment you stop, before it is sent, exactly like a photo: no signal or a closed app never loses one, and it sends itself once, later. A clip with no job picked lands in Unfiled, like a photo.

The X5 screen has a 360 photo button beside Record a walk: the whole sphere, filed to your Record as a 360 you can drag around.

The review caught a real bug: a photo taken in the first instant after opening the app could land in Unfiled while the screen said a job. Fixed for photos, uploads, notes and voice notes.

So the app is now three things. Capture: a camera inside the app that stays open (tap, tap, tap, Done, with a Photo | Video switch), a note typed or spoken, upload for anything else, and the X5 when one is linked. The Record: every photo and note by day, filed by job, stamped with time and place, kept with no signal, searchable, with the code sections on each photo. And the way out: your own Claude reads it through the connector. The app opens straight to the Record with the Photo key under your thumb.

Cut, all of it still in git history: the tool home and every tool and calculator, the ask bar, Skills and Connectors, ordering, texting, write-ups, the Google office brief, Recent, Imagine, Second opinion, Nameplate and Translate. 128 files deleted.

CompanyCam's own reviews say contractors hate three things: photos lost or stuck uploading, a slow shutter, and having to pick the job before they shoot. Tradesman is built on the opposite of all three.

The bar sits under it as "Ask about this job", answering from what was recorded on the job the Record is showing, never looking through a parked camera from the home. The Order parts, Text a client and Write up today chips leave the home (they are still in Skills); "Which way are we facing?" is the one chip left. The "What do you need?" headline is gone.

On All jobs, a day showed up twice in the Record when it touched two jobs, once per job, which read as two separate days. Now a day is one group with one heading, and when it touched more than one job each job gets a small label above its photos and notes, the Unfiled part keeping its file this day to a job key. A question asked to the bar after 8 PM Eastern also no longer lands under the next day.

On a computer, the X5 screen now says to link the camera from the Tradesman app on your phone, with a Get the Android app button.

Where it shows: each day in the Record carries a Code today row with the five most-touched sections (tap one and the Record shows every photo that carries it, from any day); open a photo and Code it touches sits under your note, each with an X to drop a wrong one, and it stays dropped; search finds photos by section number. The photo tile stays clean. A 360 from the X5 opens as a sphere you can drag, and tapping a section turns the view to what it points at.

Measured before it shipped, on 24 of your real photos: the cheap model (Haiku) was wrong on nearly half its picks, EV charging on a camera pole and a panelboard on a boom lift, so the whole photo read moved to Sonnet 5 at low effort. The finished read was wrong on 1 or 2 of about 43 picks against a limit of 3, and every pick passes a code check before you see it: a real 2020 article, section level only, never compliant, violation or safe. It costs about 1.5 cents a photo and the tags show up about 10 seconds after the photo lands.

It also fixed a silent break: when the night job was deleted on 09-24, the app stopped reading new photos at all, and editing a note quietly un-read a photo for good. A nightly sweep now collects the two old batches that were never collected and reads everything owed, and the one-time pass over every old photo runs over about five nights at half price through the batch.

Every native build now carries its number, and a small manifest sits beside the download. Inside the app, when a newer build is published, one quiet line shows on the home: App update ready, what changed, Download, and an X to hide it for that build. In a regular browser, the X5 card says the camera needs the Android app and links to the download. The /get page shows the version, the date, what changed, and the three things Android may ask (allow Chrome to install apps, Play Protect, finding the file in Downloads).

A native release is now three steps, written in CLAUDE.md: bump the build number, build the APK, run scripts/publish-apk.mjs, which uploads the file before the manifest so the notice never points at a file that is not there yet.

Asking the home bar "what does the X5 see?" asked the wrong job. With no job held, the bar asked the job with the newest capture, which is almost always Unfiled, and a camera watch is never filed there, so it answered "I can't see that from here" while the camera was live. Now, with no job held, the bar first asks whichever of your jobs has a camera on the clock.

Saying "what do you see?" out loud opened the flashlight, because "see" was one of the light's words. It is not any more; "can't see" and "too dark" still bring the light, and the camera questions go to the apprentice, which looks.

The dock is gone; the Tools pill is the one place for tools. Where it sat is RECENT: the last things Tradesman did for you, newest first, as many as fit the screen, with See all for the rest. Each line tells the truth about what happened: an order handed to your Messages app says "Opened in Messages", never "Sent"; only a send Gmail confirmed says "Sent from your email"; a calendar add, a note added to a job, a compass heading, a level reading. Press one and it opens where it lives: the note in the Record, the event in Google Calendar, the tool again.

Every hands-on tool now answers the bar, so the agent owns every tool, not just the compass. Ask "is this level" and the level answers once the phone holds still ("Down 2.5 degrees", "On 30 degrees"); ask "is my ladder right" and the ladder says "75 degrees, right on the four-to-one"; the tape says how far you walked when you stop. A tool opened by hand stays quiet. A router bug went with it: the fittings chart's "ll" matched inside "wall" and "roll", so "how far is it to the wall" never opened the tape.

A flashlight is now: say "light" in the bar, which opens it at once with no model, or Tools, then Light.

Checked: the whole suite, 763 passed, twice in a row with no retries, after the harness stopped recompiling pages under running tests.

The ask bar now carries its own row of three pills under the field, the way the Claude and ChatGPT composers do: Skills, Connectors, Tools. The More key at the foot of the home is gone; the dock keeps the hands-on tools and the Record row.

Google is never hidden. The Connectors pill wears its state on the home at all times: a green dot and "Google" when it is connected, "Connect Google" outlined in ink when it is not, and an amber "Reconnect Google" when the weekly test-mode grant lapses or a box on Google's screen was left unticked. The state paints from the phone at once and is asked again whenever the app comes back to the front, and the office brief tells the pill the moment it finds the grant dead.

Skills lists what the agent does, and a press starts it: Order parts and Text a client put their first word in the bar, Write up today asks at once, the camera skills open their tool, the calculators sit in their own group. A skill that needs Google says so on its row and leads to the Google card when it is not connected.

Connectors is one card per thing Tradesman is plugged into, Google first and biggest with what depends on it written out, then the Insta360 X5 with Possess and Link, your Claude with how often it read the record today, NFPA LiNK, and the supply house counter your orders go to. Tools is the whole grid with hold-and-drag and the Archive, moved unchanged.

Checked: the whole suite, 744 passed, four runs, none red. The home is still one screen at every size from 360 wide to a desktop.

So the home now works like ChatGPT's front screen. "What do you need?" sits in the middle, with the Ask Tradesman bar and a few starters underneath: order parts, text a client, write up today, which way are we facing. The AI tools are off the home, because they're what Tradesman does when you ask the bar. They're still one tap away under More.

At the bottom: a slim Record row with today's photos, and a dock of the five hands-on tools in his own order (light, tape, level, calculators, catalog), plus More. More holds every tool, the arranging and archive, and the Insta360.

The camera is now one chip in the top corner that says X5, with a dot that turns green when it's live. Tap it to look through the camera. The old row with its form is gone.

The full test suite passed with this and the Google connector in together: 732 tests, none failed.

The model reads the email, but it has to quote what it relied on: the words that give the day and time, the words that name the job, the phone number. Code then checks every quote against the email. "Tuesday at 9am" must really mean the Tuesday after the email was sent, at 9. A time the email never gave is dropped, and the event goes in for the day with "the time" marked as unclear. A number the email doesn't carry is never dialled. In the real-model test the model copied a job's address out of the job list into the event's place; the check threw it out because the email never said it.

When Google is connected, an email card's Send now goes out of his own Gmail, so it lands in his Sent folder and the office sees it came from him. The receipt says which address it went from. Without Google nothing changes: his mail app opens exactly as before, and the card offers to connect, once. Texts still go through his own Messages app.

The tokens are locked. They are stored encrypted in a table the browser can't read, with a key that lives in the server's environment, never in the database. The server never hands a token to the phone. Every call to Google is written to the ledger. A brief is made at most once a day, about three cents. Opening the app again that day costs nothing. Asking "what did the office send me?" only calls the model again when new mail has come in.

Still to prove on his phone: Google won't let anyone sign in inside an app's web view, so Connect has to hand off to the phone's own browser and come back. And while the app is in Google's testing mode, the connection expires every seven days, and the app will say Reconnect Google when it does.

A second pair of eyes went over it before it shipped, and tightened four things. The sign-in now refuses to finish if the browser it lands in is signed in to Tradesman as somebody else, so nobody's inbox can end up on another account. A calendar time the office sends with no zone goes in as Eastern, the office's clock, and "9am CT" goes in as Central and says so on the card — never whatever zone the phone happens to be in. A job is only tied when the email names it in whole words, so an email about 215 Oak St is not the job at 15 Oak St. And a day's brief is deleted after a week: the brief is a summary for the morning, not a second copy of his mail.

Ordering was too many steps. Now you tell the bar "20 half inch EMT connectors and a roll of 12 black for Redland, pickup at 7" and the finished order card is the first thing you see: your saved supply house, the job and the pickup time filled in from your words. From your words to sent is one press, counted by the tests. If a quantity doesn't match what you said, that line still turns red and waits for you. Status updates like "hung 2 panels today" no longer get mistaken for orders.

"Tell Mrs. Alvarez the panel is in and we're back Tuesday" writes the text for you from the job's record. You tap in the photos you want to include, and they go as one private link that shows only those photos, never your notes. You can turn the link off from the job. "Write up today" does the same for the office. Send opens your own Messages or Gmail with everything filled in.

The Google sign-in for Tradesman now exists. Kymani created it himself on his phone; I turned on Gmail and Calendar and added his work inbox as an allowed account. Next comes the Connect Google button: a morning brief of what the office CC'd him on, and cards that send from his own email without opening Gmail.

The whole test suite passed twice in a row: 700 tests, none failed.

The tools size themselves to the space. On a small phone the icons get a little smaller; on a tall phone the rows spread out instead of leaving a white band. If he ever puts more tools on the home than fit, they turn into pages you swipe, with dots, like a phone's home screen.

Nothing pushes the screen down anymore. When Tradesman answers, the answer floats over the screen as a card you can close, and it now shows the real photos it's citing instead of blank boxes. The Archive opens the same way, from a small key next to Tools.

It was measured at five screen sizes, from a small 360-wide phone to a desktop, in eight states each (resting, answering, typing, the archive open, arranging and more): in every one of them the page doesn't scroll and nothing sits in the strip Android's buttons cover.

A reviewer checking the arithmetic by hand caught a real safety problem before it shipped. On a 150 amp run in 2/0 aluminum, the voltage drop answer named a smaller wire, 1/0, as good enough. It now never names a size smaller than the wire he has. It also still refuses to size a conductor, refuses to guess a box's volume, and never answers ampacity.

The home is now his HQ. The bar is on top, then Record, then Tools, then Devices. Devices is the bodies Tradesman can live in: today the Insta360 X5, with a Possess button, and one line naming what's coming (smart glasses, a drone, a crew member's phone). On the camera screen, "Let Claude watch" puts the X5 on a shift, so the bar and his own Claude can look through it from anywhere.

The NEC: NFPA's license forbids putting its text into any AI, so the text never enters the app. Instead, any article number Tradesman says, like 210.8(A), is a link that opens that exact article on NFPA LiNK in the 2020 edition, which is the edition his exam is written on. An email asking NFPA for early access to their upcoming API is drafted in his Gmail for him to send.

Still to do: the X5's Let Claude watch has only been tested against a simulated camera, so the first real test is his. A brand-new account with no jobs can't get a calculated answer yet.

The biggest single reason the app looked amateur was one line: the app loaded a professional font (Geist) and then drew everything in the phone's system font at the heaviest weights. Now the whole app is Geist, never heavier than semi-bold, in sentence case, on white with near-black ink. Buttons are pills, fields have an outline you can find in bright sun, and every tool opens with the same header: a drawn close in the corner, its name, and its state.

One idea runs through it: a black circle means the tool asks an AI. Order, Second opinion, Nameplate, Translate and Claude wear black plates, the rest wear grey, and each day in the record carries a black Ask Claude key with a spark. It works by brightness rather than colour, so it still reads in glare.

The bar on the home now has starter chips ("Which way are we facing?", "Order parts"), shows his question above the answer, and simply says "Ask Tradesman". Sticky day headers in the record finally stick; a page setting had quietly stopped every sticky header in the app from ever working.

Still to do: a full review pass over every screen was stopped early to get this onto his phone sooner, and a few screens outside the main app (login, the signed-out page, the connector's consent page, the video upload page and the old engine room) haven't been brought into the new look yet.

Most of that already existed: the line with voice from the eye screen, the apprentice that can open a tool, and every tool mounted in one place. Three pieces were missing, and they are what this change builds. The bar now sits at the top of the home. A router looks at the trade's own words first and opens the tool it is sure of with no AI call at all: instant, free, and working with no signal. And the tool hands its answer back.

The answer comes back as words, not a screenshot. A screenshot is a picture of a number; the number itself can be shown, said out loud and checked. The compass waits until its needle has settled, then hands back one sentence, "Facing west, 270 degrees from magnetic north." The bar prints it, and says it out loud if you asked by voice. If the needle is being pulled by nearby steel, the same sentence says so.

Anything the router isn't sure of goes to the apprentice, which answers from the job record and can still open a tool itself. Each tool's "classifier" is simply the list of phrases tradesmen actually say, which was already written. Jev can slot in behind it as a smarter second guess once there's a Vercel AI Gateway key.

Testing it turned up two real problems. The phrase list had the word "connector" pointing at Claude (the app's connector), so every order for EMT connectors was routed to Claude instead of Order. And the compass drew its big reading between the two letters the dial had turned to either side, so it read as "S W · 270° N". The reading now sits under the dial, the way a phone's own compass does it.

Still to do: letting the bar connect to the X5 as a device, and having the level, the tape and the ladder report their readings the same way.

So Order does the part that actually costs time. He says or types what he needs, in English or Spanish. The app writes the order the way the counter reads it and asks the one question the counter would call back about: set-screw or compression, 1-pole or 2-pole, THHN or Romex. Then it shows an approve card with the counter, the job as the PO, the pickup time and the exact words. Allow opens his own Messages or email app with the order written in, and he presses send. The app never sends anything by itself and never touches money.

One rule matters more than the rest: a number he did not say is never sent. The app reads every quantity back against his actual words, English and Spanish number words included. Any quantity the model filled in by itself is drawn red and blocks Allow until he confirms it with a tap.

Before shipping, independent reviewers were set loose on the number guard twice, and they broke it twice. The first version trusted the model's own copy of his words. The second tried to understand trade English with rules, and trade English won: 'twelve black' is a wire gauge but 'twenty white' is twenty receptacles, so it held ordinary orders red. A guard that is red all the time teaches a man to tap Confirm without looking, which makes it worthless. So the design changed. Now the model must quote, word for word, which of his words are the count and the unit on every line, and plain code checks each quote: it is really in what he said, it really means that number, it isn't a size or an amp rating, and no two lines point at the same words. Against the real model the quotes came back exact, and every everyday order the old guard flagged now goes green, while made-up quantities still go red.

A third review made the limit plain: code can check the numbers, but it cannot fully check a language model. A model that writes a consistent mistake passes any string rule. The live test produced one unprompted: 'una caja de tornillos', a box of screws, came back as a box of wire nuts, with every quote valid. So the last line of defense is his own eyes, with the evidence in front of them. The card now prints his whole sentence at the top and 'You said …' under every line, flags any count he said that no line holds, and every answer button shows the exact words it will send to the counter. A wrong item sits right under the words he actually said, where he can see it before he presses Allow.

The prompt was tested against the real model before the screen existed, with five orders said the way people really talk. It took 2.5 to 7 seconds per order. It also got three things wrong at first: it wrote 'single-pole' on breakers when nobody said which, it read '4 square boxes' as a count of four, and it offered 'specific length' as an answer. All three are fixed rules now.

Order is the first tile on the home. The order he sends is filed on the job, and one row in the ledger counts each Allow, so we will know whether it gets used. Still unproven: whether his Razr's Messages app picks up the pre-written text from inside the app. The sent screen keeps an Open-it-again link and a Copy button for exactly that.

On the way, the three copies of the save-a-note code became one. One of them had been silently dropping a takeoff saved with no signal.

He also asked me to decide which tools he would really use. The ledger could not settle it, because every press except Record's happened on the days the tools were being tested, so it is a judgment and the reasons are written in the code. The home now opens on ten: Light, Tape, Level & bend and Calculators; then Second opinion, Nameplate, Translate and Catalog; then Insta360 and Claude, all under the Record card. Write-up, Imagine, Compass, Tally, Map, Panel, Part and Clip wait in the Archive, one press from coming back. Nothing was deleted, and a tool brought back stays back.

While doing it, a flicker turned up: the home drew every tool for one frame before reading his layout, then hid the ones he had put away, and a press in that frame did nothing. The grid now waits for the layout.

The night read is gone from the record. The nightly write-up job that filed a machine-written report beside his photos is deleted, along with the "Read the write-up" link under each day and a session-free door in the report route that only that job used. Its 14 old reports stay in the database, printed nowhere. The Morning brief key went too: its schedule was deleted yesterday, so the key armed a notification that would never come.

On logos: Anthropic's own terms allow naming Claude in plain text, but using the Claude logo in a product needs their written permission, and Insta360 publishes no public terms for partners. So the tiles keep our own icons rather than a copied mark.

Every day now wears a stamp that reads the way a phone does: Today, Yesterday, the weekday inside the week, then the date. The stamp stays pinned to the top of the screen while that day's photos scroll under it, so a long day never loses its name.

A real bug came out of it: photos were grouped by the UTC date, so anything shot after 8 PM Eastern showed up under tomorrow. Days are now the phone's own calendar day.

The grid is three tight squares with no clock stamped on every photo; the time is in the viewer. Ask Claude on each day shrank from a big pill to its small mark.

Photo note became Add, and its sheet names what each way actually is: Camera, Upload, Note and Voice. He had been hunting for Upload behind Pick one.

The photo viewer says the day once instead of twice, then the note, then a clean grid of keys: Edit note, Write on it, Ask Claude, Full size, second opinion, Imagine, Read plate and Move.

On the home, Record is a big card at the top with the four newest photos and how many were taken today, read from what the phone already holds, so it costs no network.

The cause was the order of two steps. The app shrank all ten full-size camera photos at the same time, and only saved each one to the phone's outbox after its own shrink finished. Ten big decodes at once is enough memory to crash the page on a phone, and the app reloads it. Every photo still being shrunk lived only in the page, so it died with it. On a desktop the same ten went up fine, which is why it was never caught.

Now every original is saved to the phone the instant it is picked, before anything is decoded. Then they are shrunk one at a time, and each one sends while the next one shrinks. If the page dies anywhere after you pick, every photo is already on the phone and goes up the next time the app opens.

The foot also stopped saying "10 photos waiting for signal" while ten photos were simply uploading. It now counts only photos whose send actually failed; one still going up says sending on its own tile.

A new test makes the decode never finish, kills the page, and proves all ten still land exactly once. The old code fails it with nothing saved.

Hold the heart in the middle and the phone beats: a real lub-dub about seventy times a minute, the heart pulsing with it and a line that reads Kymani's heart, beating for you. It stops the moment she lets go. On a phone that cannot vibrate, she still sees it beat.

Caught in testing before it shipped: the first cut put the touch code inside the radar's animation loop, which stacked hundreds of copies of it. Moved out and re-tested. Four places tapped with their full names, four heartbeats in 2.7 seconds of holding, then silence.

After that, she gets one full-screen moment for whatever arrived while she was away, and nothing pops up when nothing is new.

Now every tap saves one tiny file that is never changed, and reading the hearts means listing those files. A list is a fresh lookup in the database, never a cached copy. Two taps at the same moment are simply two files, and the hearts from before this change are carried over.

Tested the real route code against a stand-in storage (old hearts carried over, two taps at once both kept, undo on old and new hearts, a wrong key refused) and the page in two browsers (the count rises on every tap, and her screen lights up).

An empty place box now means the same place as last time, not a new place called somewhere. On the server, two taps in the same second can no longer overwrite each other.

Tested with two browsers, one as each of us: the overlay stays hidden until love lands, closes on one tap, her Rough reaches me, and nothing throws.

One tap on the big heart sends love from wherever I am, and it lands on her screen as a full-screen beating heart. She can tap back, or tell me how she is feeling in one tap: rough, okay or better. Every place I send from becomes a glowing heart on a radar, and she is the one in the middle.

Each of us has our own link, and a secret key in the link is the only way in. The hearts are one small JSON file in storage, and both phones check it every three seconds, so each side updates live.

Now the picture is on the sheet the instant the shutter fires, drawn from the phone's own copy — the same copy the outbox already banks so no signal can lose it. The fix is taken on the side with a hard cap and never blocks the tile. The upload is shrunk on the phone first (a long edge of 2560, which keeps a breaker label readable, at a fraction of the bytes — and under the size a function can even accept). A burst goes up all at once. When the server answers, the real row takes the tile's place in the same frame; if there is no signal, the tile says so and stays until there is.

Every opened tool now carries a way home at the top — one key, from the record, the eye, or anywhere a tool is open. The record has a Home key in its job row too.

The adversary pass caught four holes before this shipped: a ghost tile that could stand beside its own row for a frame, an upload landing on the wrong job if you switched jobs mid-send, an object URL that could leak on the way out, and a re-typed constant. All fixed; 567 tests pass.

Said plainly: the tile lands after the phone has decoded the JPEG, which on a 50-megapixel camera is a beat, not an instant — I have now put the tile up from the raw file before that decode, so the beat is gone; and a photograph the phone cannot shrink that the server refuses now says 'too big to send' instead of pretending it is waiting for bars.

At the top of the home: what are you trying to do? Type it the way you would say it — how far to the panel, too dark, what plug is this, guy only speaks Spanish — and up to three tools answer. Enter opens the first. No model, so it works on the camera's WiFi in a steel room.

The panel schedule is off the home.

Record is the gallery, and only that: your photographs and notes, timestamped, dated, geolocated, kept for good. The feed came off it. The night read, the code read and the morning brief are deleted, as you asked.

Insta360 is the eye — look through the X5, ask what it sees, record a walk. Claude is a tile: the connector, and under it Give Claude a Day — pick a day, pick what to hand over, and your own Claude pulls exactly those captures, photographs as pictures, and works with them. It also prints what you reached for today, off the ledger.

The tape draws where you went. Every step is one stride in the compass direction; press Corner where the run turns and each leg prints its length; walk back to where you started and it tells you how far off the whole walk was. With the camera tracker it draws the real trail. Save keeps the shape with the feet.

The map: I could not see from here why it was blank for you. The likeliest cause is no internet — the camera's WiFi, or a steel room — so it now says so after eight seconds and offers to try again. The first blank map with the phone in your hand will tell us which it is.

With a camera linked it connects the moment the app opens — no press between opening and seeing. Say what you want into the line and the apprentice answers from what the camera sees this second, files it, and opens the tool. Off closes the stream so the camera is not flat by lunch. No camera found says so and offers to find it again. A browser with no app says the camera needs the app and draws no dead key.

None of it is new machinery: the shift's connect path, the standby eye, the live frames, the sphere, and the turn's own pictures were all there, on a page nothing pointed at. The one new piece is a single place every phone tool is mounted, so the eye screen and the gallery open the same compass through the same door.

I had told you the camera could not be reached from the phone you carry. That was wrong — you have run the APK all along, and it loads the live site, so this landed on it the moment it deployed.

Said plainly: the eye is proven against a fake camera answering with a real X5 frame. The first look through your X5 is yours to take.

THE LINE. The search field on the belt is the one entry point now. Type and the gallery filters like it always did. Press Enter, or tap the mic and talk — a breath after two words sends it, no second key — and the apprentice answers above the keys. Its answer is spoken back when the question was spoken. Every exchange lands on the day beside the photographs, and your Claude reads it tonight through the connector.

POSSESSION. When a camera is on the clock, the line looks through it: a question with no picture borrows the parked X5's eye that second, and the answer says so. And the tools run through the line — ask for the level, the compass, the tape, the translator, a calculator, and it opens over the glass through the same door the drawer uses. No job held is not an error; it asks the job you worked last and tells you which.

THE FEED. Above the photographs: what the record made while the app was closed. The tasks the cam filed with the frame that made it say so, the night read's findings, the write-ups, a shift on the clock. Nothing on it is a control. Tick a task with one press; undo it with another. When there is nothing, there is nothing.

THE CLAUDE CAM. Every frame a parked camera keeps because something moved gets one look from the same second opinion the phone gets at a panel — one implementation. What it is sure of becomes a task on the job with the frame as proof, and you get a tap. It never states a size, a fill count, energised or safe. It looks when the box says something moved, at the end of a shift, and once a night for anything missed — not on a ten-minute cron, because your Vercel plan rejects one at deploy and a failed deploy is worse than a slow look.

Said plainly: the cam has not read a real shift yet — the box was off the network this morning. The first live look is the measurement. And 'NEC-backed' is still not true; it flags what is worth a look and says what it saw.

You then said the crew idea only helps teams, and you were right, so the crew is laid as a foundation and not wired. What shipped is the solo loop.

SAY IT. A fourth way behind Photo note. The ear opens the moment it does, you talk, and the words land on today with the fix under your feet, through the same outbox that keeps a photo when there is no signal. Android hands the same sentence back twice; it is written once. On a ladder nobody types.

THE DOOR TO CLAUDE IS ON THE RECORD. The gallery is the app and until today it had no way to Claude at all. Now the three dots row has Ask Claude for the job you hold, every day has one that names the job and the date, and every photo has one that names the capture and asks Claude to pull it. Connect Claude is right beside them.

THE MORNING BRIEF. At 6:30 the record speaks first: how many things are open and where, the first line of what the night read found, and whether yesterday was written up. Built from rows, no model, so it cannot invent. A quiet night sends nothing. Turn it on once from the three dots.

/connect is the one page that says what this is and installs the connector in three steps, and it reads the ledger to tell you whether your Claude has read the record today. And the connector now carries its own skill, so every Claude that connects already knows it is talking to a competent electrician, how to cite, and what it never says.

On the Claude cam: yes, it is the cooler thing, and it is already most of this codebase. It is the richest input to the memory, not a replacement for it. Not yet NEC-backed, and I will not let you say so until the code is licensed.

Every AI cleaner now refuses a value that contains that markup, so if it ever leaks some other way you get a blank, not garbage drawn on a plate.

The Jasper thing. What made Jasper work was never the models, it was that every capability sat where the work already was. So until now a second opinion on a photo you had already taken meant closing the photo, opening the drawer, opening the tool, and photographing the thing again. Open any photo now and there are three keys under it: Second opinion, Imagine it changed, Read the plate. Each one opens on that picture. Same tools, one extra door.

An imagined frame gets none of those keys. A second opinion on a picture of something that does not exist is nonsense, and running Imagine on Imagine compounds a lie. Imagined tiles are marked on the sheet as well as in the viewer.

The five calculators went into their own folder next to Catalog. A journeyman does Ohm's law in his head and reaches for voltage drop twice a year; neither belongs on the same row as the flashlight. The top of the drawer is now the five AI tools, then the things you reach for standing up, then the four that need the box.

Most of what the model is told is about what must NOT change. An image model given "put a GFCI here" will happily redecorate the room, and a customer who notices the wrong floor stops believing the outlet.

And an imagined frame is never evidence. That mark is burned onto the picture, not next to it, because a badge beside it disappears the moment somebody screenshots the frame and sends it on. The before is one press away, because the pair is the argument. And saving it stamps the row itself as imagined with what you asked for, so the record knows, not just the screen. This app exists so your photos prove what was on a wall on a Tuesday. A generated picture loose in that would poison it.

SECOND OPINION. Shoot what you are looking at, add one line of context if you want, and get back up to six things to go and check, surest first, each one tied to something it can actually name in the frame. Underneath, a block of what that photograph cannot tell it. It is a second pair of eyes at 4pm, not a lecture.

WRITE-UP. Pick a day and it turns that day's notes, times and streets into the three things you have to send somebody: a paragraph for the customer, line items for the office, and what is still open. Copy key on each. Anything the record did not say is listed as unclear instead of invented, and any sentence that sizes a conductor, cites an article or names a price gets dropped.

THE DRAWER IS AN APP SCREEN NOW. You said you did not know the outlet and ladder tools existed, and that some tools felt like they were competing. They were not, but a flat grid of twenty tiles cannot say that. AI tools are at the top with an AI mark on the tile, so you know before you press that it calls out and costs money. Then the tools you operate. Then a CATALOG folder that opens in place, holding the things you look up rather than operate: plugs, fittings, wire colours, knockouts and ladder angle.

TRANSLATE. The latch shipped yesterday, so if you were still holding the key you were on a cached bundle. But there was a real problem underneath it, and it was never the model. I measured both: Haiku lands in about 730 milliseconds and Gemini in about 880. The problem is that your phone's recogniser only listens in one language at a time. You speak English, it says the Spanish out loud, and then it is still listening for English when the other man answers in Spanish. Now the ear turns to whatever it just spoke, because the person who heard it is the next one to talk. Hand the phone over and let him answer.

THE TAPE. It had never worked once on your phone, and the reason was not the plumbing. It measured with ARCore through a native plugin, so in a browser it mounted straight into a blank screen, which is what you saw as the text prompt with no UI. It now knows two ways to measure and takes the best your phone can actually do. With the app build it uses the camera. Without it, it counts your steps, which works everywhere, indoors, with no signal. Walk a distance you already know once, ten seconds, and it learns your own stride and gets to about five percent. It says which method it used and how good the number is, rather than showing you a decimal it cannot back up.

NO TOOL NEEDS A JOB. The tape, and everything else on the phone, opens and works with nothing held. The three that make something worth keeping, the tally, the panel schedule and the nameplate reader, file the same way a photo does: to the job if you are on one, to Unfiled if you are not.

WORK AND HISTORY IS GONE from the drawer. The one idea in it worth keeping was that your work has a shape on the ground, so that is now the MAP: every photo and note on the ground where you took it, today, this week or everything, and tapping a mark opens that photo. It tells you honestly how many have no fix rather than quietly dropping them.

AND FOURTEEN NEW TOOLS, every one of them drawing rather than listing. A flashlight with steady, strobe, SOS and a full-screen white that works on a phone with no LED. Ohm's law on a power wheel that lights the two you solved and shows the formula. Circuit load as a bar filling against the breaker with the eighty percent line drawn. NEMA plugs with all seventeen faces actually drawn, filtered by volts and amps, each one telling you what it is NOT, because a 14-50 is not a 10-50. Wire colours drawn as real conductors with every voltage to ground laddered to an earth bar, and each colour marked required or convention, which is the part nobody is ever told. Conduit bodies that ask which way you need to come out instead of making you remember which letter. Knockouts, hole saws and tap drills drawn to scale against each other. A panel schedule you build by tapping spaces, odds left and evens right, with a two-pole drawn as one tall breaker. A converter where AWG is computed from its definition rather than looked up. Ladder angle, where you lay the phone on the rail and it draws the ladder leaning at your live angle with the safe band on the ground. A tally for a takeoff. And a nameplate reader: photograph a data plate and get the numbers back drawn as a plate, with anything it could not read shown as an empty slot rather than quietly missing.

447 tests pass. Every tool is opened by a test that fails if it shows a dead key, navigates away, hides its way out, or leaves a control where Android's nav bar eats it.

So every one of them draws now. The offset is a pipe with both marks on it, the angle arced where the bend is, the twelve inches dimensioned along the slant where your tape actually lies, and the ghost of where the pipe would have ended if you had not bent it, which is what shrink is. The stub is an L standing on a floor with the height dimensioned from the floor and the mark measured from the end you hook your tape on. The saddle is a pipe going over the thing that is in the way, centre mark on top, outer marks either side, with the 45 and the two 22.5 labelled where they happen.

Under every drawing are numbered steps that tell you what to do, in order, with the number inside the step. Not shrink 1 5/8 but your pipe will end up 1 5/8 shorter, so measure that much extra before you start. The arithmetic is still there, folded away, for when you want to check the tool rather than trust it.

The level is a protractor with the pipe lying on it at the angle you are holding, a bubble riding it, and the tick lighting up when you hit one of the angles a bender is marked for. Above the dial it says either on 30, stop bending, or how many degrees you have left to go. That is the actual question when your foot is on the pedal.

Box fill draws the box filling up, each thing in its own band with its name on it, and the rim it cannot cross drawn as a line. Go over and the stack spills above the rim in red. You see in one look that one receptacle takes as much room as two conductors, which is the rule people get wrong, learned in a second instead of read in a paragraph.

Voltage drop draws the run. A panel, the wire, the load, and the volts falling along it, with the loss shaded in. Every size is a bar with the three percent line drawn across them, and pressing any bar redraws the run with that wire in it, because the real question is what going up a size buys you.

Two things I got wrong on the first pass and fixed: a responsive drawing placed directly in a grid collapses its row to two pixels and paints underneath everything below it, and the bender sizes were coming out in the wrong order because JavaScript sorts a key called 1 before a key called 1/2.

You also said the job name at the top of the gallery means nothing to you. It said Vitronics with no hint that it was a filter, that everything below had been narrowed by it, or how to get back. It now says Showing or Only, and there is a Show all key whenever something is being filtered. New job moved into the three dots menu, because after the unfiled change you never have to make a folder before you can shoot.

And the translator was repeating itself. That was not the model. Android hands back a sentence it has already finished while it is still working on the next one, and the code was adding it again each time. It now records each piece once, by position, so handing it back changes nothing. There is a second guard that drops a line identical to the one before it.

LEVEL AND BEND, one tile. The level was already being calculated inside the compass and thrown away. The same four numbers that give you a bearing also give you the tilt, so it was three lines of arithmetic that were sitting there unused. The important part: it uses no magnetometer at all, so it works inside a steel panel room, beside a strut and in the bed of a truck, which is exactly where the compass gives up and tells you it cannot help.

Lay the phone along the bender handle and the big number is the angle of that run. Underneath it, the cross level tells you when you are cocked, and goes red past three degrees, because a cocked phone measures your hand and not the pipe. There is a two press zero: read it, turn the phone end for end on the same surface, read again. Turning it end for end cancels the real angle out, so what is left is your phone's own error, which on most phones is about a degree. That takes it to about a tenth of one.

The bender face does offsets, stubs and three point saddles. Every answer shows the arithmetic under it and the rounded number you were taught, so a 30 degree offset says 1/4 inch of shrink per inch of rise like your book does, and 0.268 like the trigonometry does. Marks come back in sixteenths, so it says 12 3/8 rather than 12.37. And a stub shorter than the bender's take up is refused instead of answered, because that stub cannot be made with that shoe.

BOX FILL. The value is not the table, it is the counting rules, which are the part people get wrong. A yoke is two, at the largest conductor connected to it. All the grounds together are one. All the clamps together are one. A pigtail that starts and ends inside the box is not counted at all. Every line on the answer prints the article it applied, so you can check the tool rather than trust it. It will not guess the box volume, because the code already requires the box to be stamped and reading it off the bottom is what you do anyway.

VOLTAGE DROP. It needs no code data at all, so it works with no signal at the end of the run. It shows every size rather than one recommendation, because the real question is what going up a size buys you. Two things are printed permanently and not behind a fold: three and five percent are recommendations in informational notes, not rules, so going over is not a violation; and this is the DC approximation, which reads low on a long run in steel. It will never answer what size wire a load needs. That is ampacity, and four of the five articles that make an ampacity answer legal are not in this app.

All the arithmetic is tested on the bench, twenty two cases, against the numbers the trade already knows. None of the three calls a model, a map or the network.

It needed nothing new. The camera already hands back a stream, and the torch is a setting on that stream, supported in Chrome for Android since version 59 and therefore in the app's WebView. No permission, no plugin, and no APK rebuild. It works on the install you are carrying right now.

Three rules, all of them about not lying to you in a dark room. The key only exists if that camera actually has a light, so it disappears when you flip to the front camera rather than sitting there dimmed. The capability is checked after the camera has actually started, because asked too early the browser says no on a phone that has one. And the key shows what the light is doing, not what it was asked to do, so a refused request can never draw a lit key over a dark panel.

It also goes out when the camera does. A camera stopped while the light is on leaves the LED burning on some Android builds until something else claims it, which is a flat, hot phone in your pocket.

There are fifty rows of EMT conduit fill for THHN in there. I recomputed all fifty from Chapter 9 the way the book does it, 53% of the raceway for one conductor, 31% for two, 40% for three or more. Six of the fifty came out different. Then I checked them a second way against two published Annex C.1 tables. Seven came out different, and not the same seven.

Three methods, three answers, every one of them within about a percent of a rounding boundary. That is not something anyone can settle from a browser, and a wrong fill count is pinched insulation on a pull. So the code reader now refuses that table outright and is told to give you the method or say nothing. The rows are still in the database and still in the seed file, with the exact disagreements written at the top, so they can be checked against a real code book and fixed.

The same pass added a second refusal that was never written down. Table 310.16 is in there and its numbers are right, which is exactly what makes it dangerous: ampacity alone gives an illegal wire size. Termination temperature, the small conductor limits for 14, 12 and 10, ambient correction and bundling adjustment all bear on it, and four of those five are not in this app's data. The reader is now told to name what it cannot check rather than size a conductor.

Anything I build later that does arithmetic on the code inherits both refusals.

That is not a man who dislikes folders. That is a man who wanted to take a photograph and was made to name a container first. So the folders stay, because the five that hold the work are genuinely useful, and a tag you have to type before you shoot is a folder wearing a different word. What went is the requirement.

Photo note no longer asks which job. Shoot, pick or write with nothing held and it lands in Unfiled, which shows up in your gallery grouped by day and street like everything else. Unfiled is the second entry in the job picker once it exists, under All jobs, so where the photo went is answered by the list itself. It is not a job and it never reads as one: it cannot be renamed, deleted or shared, and it never appears in a list that asks you to choose a job.

The asking moved to where you can see what you shot. A day of unfiled work carries one key on its heading that files the entire day onto a job in one gesture, the day's notes with it. A day is the right unit. You work one job a day far more often than three, and ticking every photo first is the filing cabinet this change exists to remove.

Two things still need a real job and say so in place rather than failing quietly: a clip or a 360 walk, because both ride the shop box's rails and the box is keyed by job, and a keep, because a keep is pinned to a job for good.

While wiring this I found that the photo route had never checked the job you post to actually belongs to you. Any signed-in account could have filed a photograph into any other account's job. It checks now.

It also could not see your photographs. Reading a day gave it text and nothing else, which is a strange thing for a record whose entire content is pictures. Ask for a day with photos now and it gets them, up to eight, each with its time and its note and the door back to it, and it says plainly when there were more.

The Part tool can read a printed label instead of guessing at one. Point it at a barcode, a QR, or the data matrix on a breaker and it reads the number exactly. Identifying a component from a photograph is a guess, and a guessed model number is how the wrong interrupting rating ends up in a panel. When it reads one, the card says so in as many words: read off the label, not a guess.

It only appears if your phone can actually do it. No detector, no key — rather than a button that takes a press and fails. And if the scanner breaks at runtime, which happens on Android when a system module has not downloaded, it says so and falls back to shooting the part, which still works exactly as it did.

So the day says so itself now. Scroll to a day that was written up and there is a line under its heading, and it opens the write-up. That is where it belongs — under the day it describes, where you are already looking — rather than behind a menu you would have to know about.

The other door is sharing. The app has been able to mint a read-only link to a job, expire it, and kill it, since August, and the page that renders it for whoever you send it to has worked the whole time. Also no door. Share this job now sits beside Rename and Delete, because it is the same kind of thing: something you do to a job rather than to a photograph. It shows the link, copies it, tells you when it expires, and can take it back. That last part matters most — a link you cannot revoke is not a link anyone should risk sending to a general contractor.

Notes go through the same queue now. Written to the phone first, sent second, and if it cannot go out the foot says so and it goes on its own when the bars come back. It carries the same one-note-however-many-tries key the photos do, because the same sentence arriving twice in a record that prints every note in full reads as two separate observations rather than one.

Every queued photo now carries a key minted once at the shutter, and every retry carries the same one. The server answers the second arrival with the first photo instead of making a new one. A test proves it: the response is killed mid-flight, the queue retries, and every attempt carries one identical key.

Found a second bug while doing it. The queue was sending the shutter time as a date string and the route reads it as a number, so it was quietly being discarded. A photo taken in a basement and sent an hour later would have been filed under the moment you walked back outside, which puts it on the wrong day in a record whose whole organising principle is the day.

The house already knew better. The video path has carried a line since August saying a recorded walk must never die with an upload error, and it banks the recording to the phone before it touches the network. Video learned that lesson and photographs never did.

Every photo is now written to the phone first and sent second. Not on failure, first — a catch around a network call cannot rescue a file that only ever lived in a variable. If it cannot go out, it waits, and the foot of the gallery says so in plain words: one photo waiting for signal. It goes on its own when the bars come back, when you reopen the app, or when you walk up out of the basement, which is what actually happens.

Nothing ever leaves the queue because it failed. It leaves when the server has accepted it and not before. And the browser is asked not to evict the storage it sits in, because a photograph waiting for signal that gets quietly cleaned up is the same bug again.

Two tests hold it: one takes a photo with the network genuinely unreachable and proves it is kept, announced, and sent the moment the connection returns; the other closes the app and reopens it and proves the photo is still queued, because it is on the phone rather than in the page.

Small fix underneath it. When a tool opened, the container moved focus to the first key, which lit that key up with a ring as though you had pressed it. That is a lie about what just happened. The panel itself takes focus now, which is the correct way to open a dialog anyway: a screen reader lands on the surface and reads its name, tab still walks the controls, and nothing wears a highlight nobody asked for.

The compass was the only tool that drew a text pill to close instead of the same mark in a circle everyone else uses. Small, and exactly the kind of small thing that makes software feel assembled rather than made. There is a test now that opens each tool in turn and checks the way out is the same size in the same corner.

And a job tool no longer swallows your press. Opening the panel reader or the part finder leaves the gallery and boots the other half of the app, which takes a second or more on a phone, and until now pressing it did nothing visible at all while that happened. A key that eats a press is the most broken thing an app can do, and a man on a ladder just presses it again. It now says what it is opening and on which job, and the other tiles go quiet. That needed the navigation held back by a single frame, because setting the words and leaving in the same instant paints nothing.

Worse, each of the five drew its own full screen container. Five near identical boxes that could drift apart on any given night, and four of them sitting on the same layer so if two ever opened together they would have argued about who was on top.

There is one container now and the motion lives in it once. A tool lifts sixteen pixels and fades over a quarter of a second while the gallery behind it darkens, so your eye is told where the thing came from and the screen reads as one surface moving rather than two unrelated pictures. Coming back out takes about two thirds as long, because waiting to leave feels like lag while arriving slowly feels like weight.

Leaving was the harder half. A screen normally throws a tool away the instant you close it, so there is nothing left to animate. The container owns the close now: it holds the panel for the length of the exit and only then lets go.

It also knows it is a modal, which none of them did. Escape closes it. The gallery behind stops scrolling instead of sliding around under your thumb. Focus moves inside and stays inside rather than walking off the back into a page you cannot see.

And the tools are warmed while the gallery is idle. Each one is loaded only when you open it, which is right, but it meant the first tap bought a download before a single pixel moved. Now the code is already within reach, so the tap is the animation and nothing else.

Minimally, as asked. No bounce, no overshoot, no blur that costs a frame, no staggered anything. One rise, one fade, one scrim. If your phone is set to reduce motion it skips all of it, because motion is a courtesy and someone who turned it off has said so.

Ask your Claude about any walk now and it can pull the actual seconds rather than telling you the frames are not ready. Searching one of them for warehouses comes back with seventeen described seconds, each a link straight to that moment of the video.

Also written down: the box cannot see code changes you commit in the same folder it runs from. It checks whether pulling moved the repo, and since committing already moved it, the pull does nothing and it never restarts into the new code. It had been running the seventeenth's copy all day. The per-job scripts are spawned fresh each time so fixes in those land immediately, which is why the frame extractor fix worked without touching anything. Only changes to the main worker need the task restarted by hand.

So the ear latches. One tap starts it, one tap stops it, and while it is on your speech is cut into clauses and each one is translated and spoken while you are still talking. The conversation and the machine run side by side instead of taking turns.

A clause goes off when what you are saying has held still for six hundred milliseconds and runs at least four words. That is the natural breath between clauses: long enough that a hitch mid-sentence does not cut you off, short enough that nobody waits on it. The phone's own end-of-speech detection is only the backstop, never the trigger, because it sits on a second or more of silence before it decides you are done, and that silence was most of the complaint. Only the new words are ever sent, never the whole sentence again.

The line still being heard is drawn grey with its last two words held back, because the recogniser constantly revises its own tail and a line that rewrites itself under your eyes is unreadable. What you actually said stays on screen next to what it became, so a bilingual third man on site can catch the machine.

And the important one. If a number or a part code you said does not survive into the translation, that line is not spoken at all. It goes red and says so, and you read it out yourself. Two hundred and seventy-seven coming back as one-twenty is the mistake measured in amps, and a wrong amperage said out loud in a confident voice to a man who cannot see the screen is the worst thing this tool could do.

There is also a side switch now. Telling the ear which language to expect used to be a hint the model could recover from across a long turn. At clause pace it stops being a hint: four words heard by the wrong ear are four wrong words with no context left to repair them.

Honest about the ceiling: this lands about two seconds after you finish a clause, and most of that is the round trip to the model rather than anything on the phone. Getting under a second means either a free fast host or an on-device translator, and the on-device one needs a new Android build. Both are written up and neither needs you to spend money.

So the warning now names the cause you can act on. Waving the phone in a figure eight does not help a man standing in front of an open enclosure, and telling him to do it is the wrong instruction in the wrong place. It says step ten feet off the steel and read it again. And a heading saved while the needle was being pulled now carries that fact into the record permanently, because that line gets read months later by you or by your Claude with no way left to know the conditions. An unmarked bad heading is worse than no heading. It is a wrong fact wearing a right fact's clothes.

The panel reader had a sharper version of the same problem. A directory in this country runs odd circuits down the left column and even down the right. A reader that loses track of the column writes the right words against the wrong number, and nothing about the page looks wrong. Beyond that, a directory is hearsay to begin with: it was written by whoever was there last and is routinely wrong, so transcribing it perfectly still gets you a wrong answer. The app can make the transcription trustworthy. It can never make the directory trustworthy.

So the document says what it is on its face. It is titled what the directory said, with the date it was photographed. Every row says the directory says. The line about ringing out the circuit before working on it is part of the saved document rather than something the app draws around it, because this gets shared and printed and taped inside a door, and a warning that only exists on a screen is not a warning.

The translator also grew a guarantee rather than a request. Its instructions have always told the model never to translate a voltage, a wire size or a part number, but an instruction is a request. Now the numbers and part codes in what you said are checked against what came back, and anything that went missing is reported. Two hundred and seventy-seven volts coming back as one-twenty is the mistake that gets measured in amps.

Two things were wrong and neither was the part anyone would have guessed. First, the shelf had never been handed a job. The only door that can queue an already-uploaded walk looks for rows whose shelf status is queued or stitching or extracting, and a walk uploaded before the shelf existed has no shelf status at all, so it can never match. Every walk in the record predates the feature. It was not broken or switched off. Nobody had ever asked it to run.

Second, once asked, it died in four seconds. The frame extractor passed ffmpeg a flag called vsync, which was deprecated for years and has been removed outright in the build running on the box. Newer ffmpeg does not ignore an unknown flag, it refuses the entire command. One word, and the whole feature was dark.

Both are fixed. The extractor uses the current flag, and there is now a proper backfill that finds footage with no shelf entry and queues a couple per sweep, oldest first, deliberately slow because each walk is a hundred-odd megabytes to fetch before a single frame is cut.

Proven on a real walk rather than assumed: forty-five seconds of the WattzLED shop, forty-five frames and two hundred and twenty-five files in twenty-five seconds. It now reads Ready for Claude, and searching it for warehouses returns seventeen seconds, each one a link straight to that moment of the footage. That search is also the first thing to actually use the full-text index applied this morning, which until now had a correct column and no reachable reader.

So every tool wears its own ink now, and the inks are the ones the record already uses rather than a new palette invented for the occasion. Measure keeps the teal its measurements have always printed in, the clip keeps its orange-red, the walk keeps its violet. The plates are tinted glass: a diagonal ramp from a lit top to a shaded foot, a soft bloom at the top left that is the thing that actually reads as glass, a bright rim along the top edge and a dark one along the bottom, and a tight contact shadow under a wider one. They press in under a thumb, because a key that does not answer a press feels broken long before it looks wrong.

Four across instead of three. Both groups hold exactly four tools, so each one now lands as a single clean row instead of three and a stray.

The bigger change is that words can now live ON a photograph. Shoot a panel and the editor opens on the shot you just took; tap anywhere to drop a label, drag it to move it, reopen it a week later and move it again. Nothing is ever burned into the picture. A label a man drops at seven in the morning is a first guess and by noon he knows better, so the words are stored as position data beside the photo and the original file is never rewritten.

The honest part of that story is that almost none of it was new. The data model, the validation, the drawing and the writing end of the API had all been built in August and were sitting live and unused. Even the indexing pass already composited those marks over the photo before the vision model read it, which means the connector could already find words nobody could write. What was actually missing was the editor and the layer that draws them, and the layer had been deleted in a dead-code sweep for the crime of having no door. It was restored rather than rewritten. The temptation was to design a fresh overlay format, and that would have been a second implementation of something that already worked.

Words on a picture are still words, so they behave like words everywhere: the white dot on a tile counts them, the line under the day prints them beside the thumbnail when there is no typed note, and the one search field finds them.

The tool drawer is an app grid now instead of a list — big plates, three across, the name under each one. The sentence that used to sit beside each row is not gone, it is the tile's label for a screen reader and it speaks up the moment that tile needs to ask which job. There is a Devices tile too, which is where connecting through another device lives. Today that means the Insta360, rendered through the one camera form that already existed rather than a fourth copy of it. Glasses, drones and another tradesman's phone are named there as plain grey lines with the one thing that would have to be true first, because a key that takes a press and does nothing is worse than a page that admits it is not built yet.

And the drawer carries a quip he asked for: the Swiss Army tradesman.

That matters more than it sounds for the translator. The phone's own speech engine and the helper that asks for the microphone both landed on the fourteenth, six days after the installed app was built. The web half of the translator reaches any phone the moment it deploys, but the microphone never gets asked for without that helper, so hold-to-talk could not have worked on the old build no matter how good the route was. The route itself was proven today against a real key for the first time.

The instruction for building it, written in two of our own documents, was wrong. It passes the Java path as a dash-D flag and says to run it from PowerShell, and PowerShell reads a bare dash-D as the name of a task, so the build dies complaining it cannot find a project called C. Setting the environment variable instead works first time. Both documents now say so, with the exact error, because a wrong instruction in a file read at the start of every session costs more than no instruction at all.

The gallery read was taken apart hop by hop across sixty-eight real reads in the ledger. Half a second of a typical read is the sign-in check and the job list; the photo query, the only hop an index can touch, was already the smallest of the three. The index does work and is used on every read, but the same query returning the same two hundred and seventy-five photographs costs a quarter of a millisecond without the notes attached and twelve with them. Almost all of the database cost is unpacking the JSON on each row, which no index can fix. And the seven seconds everyone remembers was not the photographs at all. It was an eight and a half second sign-in check.

The full-text index turned out to be looking in four rooms that have never held anything, while missing five that hold almost everything. It indexed the fields only the connector's frame-writer fills, which has never run, and skipped the conditions, materials, counts, site context and street address that get written on every single photograph the indexer reads. So the record could not find a defect, a wire size, a material, an address, or a note somebody drew on a print by hand. That is fixed, and because a stored column freezes the moment it lands, fixing it today cost two seconds where in six months it would have cost real downtime. Searching for corrosion went from forty-nine hits to two hundred and twenty-five. Stranded copper went from four to twenty-nine. Rockville went from two to nineteen.

The tool drawer now writes one line to the ledger every time a tool is opened. Eleven tools have been shipping with no way on earth to know which ones a man actually reaches for, and in a month they would have been kept or cut the way the last nine front doors were, by taste, after the work. The sketch for this was five lines and one of them was wrong in a way that would have inverted the answer: the ledger batches its lines a second and a half behind, and four of the tools navigate away immediately, so those four would have lost every line and read as if nobody ever opened them. They now flush before they leave. Work and History got its own mark too, since it is a link rather than a key and would otherwise have read as the one door nobody uses.

The translator answered for the first time. It had been written, typechecked and shipped without anybody ever seeing it return a sentence. It keeps home run as home run, leaves a Square D QO120 alone, turns pinche panel jodido into something a foreman would actually say, and flips direction by itself without being told. Holding the effort low buys nothing measurable, and a smaller model is twice as fast but calls a lug a nut, so it stays where it is.

The argument underneath it: this project has had ten front doors and nine are dead, and every one of them died the same way. On a screenshot, on 'I fucking hate our play page', on 'dogshit'. Every one of those verdicts was correct. The problem was never the taste — it was that the taste arrived after the build. The instrument that would make it arrive earlier already exists in this repo, has been writing a row for every external call since September 4th, and has never once been read as a dataset.

So the first three items are not features. Apply the two SQL migrations that are sitting in the repo unapplied — one of them is the gallery's own indexes, which have never been created, while 'still slow' has been the complaint all week and an entire measurement apparatus was built to chase it. Read the ledger with five queries, one of which asks whether anybody has ever actually used the connector, which is the core strategic bet of the whole product. And give the tool drawer a ledger row, five lines, so that in two weeks the drawer can prune itself on evidence instead of on a verdict at one in the morning.

Then, while checking whether a coherence sweep was due, the proof that it is: CLAUDE.md says in one place that pad/Keys.tsx and pad/KeysSheet.tsx were deleted on September 5th, and a few paragraphs later says they survive 'because the tool sheets type through them'. The folder holds exactly one file. Neither exists. Every session for the last seventeen days has been told a file that is not there is load-bearing. Fixed in this commit, under the file's own rule about contradictions — a stale line in CLAUDE.md is the most expensive bug in this repo, because it is the one thing read at the start of every single session.

The gate is this: three tools have been written this week and not one of them has been held in a hand. The compass has never been pointed down a real street. The tape has never been walked against a real tape measure. The translator has never once been called against a real API key — it is verified to compile and to be wired, and that is all it is verified to be. Nothing in phase two starts until those three come back with numbers instead of a thumbs-up.

Phase two is the phone 3D scan Kymani asked for by name. It could not be done from the cloud: that checkout is shallow, 51 commits deep, and the ArScan lane was deleted on September 4th — the code is genuinely not in that repo's history. It is in his. The PRD carries the git commands to find it and one hard rule: it comes back as a single drawer row, and only if a walk on the real phone produces a point cloud the viewer can open. A dead lane restored is worse than a dead lane deleted, because now it has a door.

Phase four is the one that matters most given this project's history. Kymani's list of tools ended in 'etc.', which is an invitation — and it is also exactly how this app came to have ten front doors with nine of them dead. So new tools get a holding pen and four gates: used standing up in under a minute, not a workflow, needs nothing but the phone or an existing wire, and asked for in his own words rather than inferred from a category. Nothing in the pen is approved. The point of the pen is that a good idea at one in the morning has somewhere to go that is not main.

So the tape moved up into ON THIS PHONE, beside the Compass. It turns out MeasureSheet takes exactly three things — the job's name, a way to save, and a way to close — and carries its own ARCore tracker inside. It never needed the engine room at all. It only ever needed a job to file the run to. One tap from the belt, the sheet is on the glass, and you are walking.

The one thing that had to be done carefully: the tape now files from two hands, the gallery's and the WORK belt's. The 2026-08-26 law about the camera says duplicating a save handler is exactly the second implementation that always drifts — so the POST itself now lives once, in lib/measure-save.ts, and each hand keeps only its own aftermath. The engine room still bumps the job's count, toasts, and attaches the footage to whatever task is armed. The gallery just reloads its feed so the run lands on the page instead of on the next open. The wire is shared; the consequences are not.

Also fixed, found by reviewing my own work from yesterday rather than waiting for it to bite: the translator's ledger row was being written with no user on it, which means History's Calls filter — scoped per owner — would never have shown what the translator cost. It passes the user now, the way /api/ask always has. And the language pair, which is interpolated into the model's system turn, is matched against a real BCP-47 shape instead of merely truncated to twelve characters. A language code is never a place to write a sentence.

But the audit turned up something better than a number. On September 18 the three quiet links to /field came off the gallery as 'old setups'. Nothing replaced them. So eleven finished, tested, shipping tools — the tape that counts the feet you actually walked, the X5 link, the panel reader, the part finder, the clip, the day itself — went on riding in the bundle with NO DOOR ANYWHERE IN THE APP. The measuring wheel Kymani asked for today had been written in August and had been unreachable ever since. The home screen was 1,910 lines of reachable code sitting on top of 10,451 lines nothing pointed at.

So: a TOOL DRAWER. One key on the belt, every tool behind it, and it is the only door — nothing gets hidden a second time. The drawer says out loud which kind each tool is. ON THIS PHONE means it needs no job and no network and opens right there over the gallery, the way the Compass already did; a route would pay for the app's boot twice. ON THE JOB means it needs the engine room, so it opens /field?tool=<id>&job=<siteId> — a new door on that page that fires the very same key the belt there fires. One tool, one implementation, reached from two places. As a tool earns it, it moves up into the first group.

The compass keycap that stood on the belt for a day is now the drawer's key. That is the fix, not a regression: a compass with a key of its own while the measuring wheel had no key at all was precisely the disease.

And the second thing he asked for, which belongs on that shelf: TRANSLATE. Hold the key, say it, let go — the phone says it back in the other language, out loud. It flips by itself, because two men passing one phone cannot stop to set a direction between sentences: you name the pair (English and Spanish by default, the pair that is actually on American jobsites) and the route detects which half was spoken and answers in the other. It prints which language it heard, every time — a translator that will not tell you what it thinks you said is worse than no translator. Trade words are the domain, so a panel schedule does not become a timetable, and part numbers, breaker sizes and manufacturer names come back untouched. Save it, and the exchange files as a note under today, where the gallery and the connector both read it.

What it is NOT is the Ghost voice pipeline, which stays deleted. No wake word, no streaming audio, no background listening, no Deepgram, no ElevenLabs. This is the September 14 amendment used exactly as written — voice as input and output on one line: the phone's own recogniser hears, one call turns the words around, and the one ledgered door to the phone's mouth says them. Three rows in the ledger per exchange, and tests/ledger.spec.ts was run to prove it rather than assumed.

Six new tests pin the drawer: that every tool is in it (counted, not trusted — the whole bug was a tool nobody could find), that a job tool goes to the engine room and never spawns a second copy of itself, that on All jobs it asks which job instead of dimming, that a phone tool opens without a route, and that law 1 still holds — nothing operable comes to rest in the foot's 52-pixel strip. The compass spec was rewritten to come in through the drawer.

Not done, and said plainly rather than quietly skipped: phone 3D scanning cannot be restored from this checkout — the ArScan lane was deleted on September 4 and this clone is shallow, so that code is not in its history; it needs the full repo and an APK build, which is Kymani's machine. The Code check has no sheet of its own (it is a skill of the apprentice), so it is not in the drawer yet.

So the grid is gone. The group is the DAY, the way every phone gallery does it, and the streets ride underneath as the day's caption instead of being the thing that cuts it up. A day cannot fragment, because a date is exact — whatever the GPS did that afternoon, the afternoon is one block. On All jobs a day still splits per job, because two jobs' photographs should not land in one contact sheet, and nothing else splits it.

The second half: a photo's note is back on the surface. The white dot on a tile told you words existed but not what they said, and you had to open the photo to find out. Now every photograph that carries a note prints it under that day's sheet, in full, beside its own small thumbnail, and tapping the line opens that photo. That is the bonded-pair rule the rest of the app has followed since August — anywhere a photo shows, its field note shows with it — finally kept on the one screen that gets opened most. The words still stay out of the squares; a contact sheet is for pictures.

The part that had to be right is true north. Every phone sensor reports MAGNETIC north — Android's absolute orientation comes off the geomagnetic rotation vector, and Apple's compass heading is documented the same way — and in Maryland magnetic is about eleven degrees off. Eleven degrees is the width of a street, which is exactly the question being asked. So the declination is computed from the fix under your feet through the World Magnetic Model, the current one, epoch 2025 and good to 2030. It is never a constant: it reads eleven degrees west in Rockville and fifteen degrees east in Seattle, and it drifts every year. The line under the reading says which north you are looking at, always. A compass that will not tell you what it is measuring is worse than no compass.

The math lives in its own file and is bench-tested rather than checked by turning a phone around: that a flat phone reads 360 minus alpha, that the reading survives being tilted upright instead of going to pieces (the top of the screen and the back camera each go blind where the other is strong, so the longer one wins), that a turn from 350 to 10 degrees goes the short way and not the long way past south, and that the smoothing eats the jitter while staying three degrees behind your hand at four tenths of a second.

If the magnetometer is swinging — and beside a panel or a truck bed it will — the screen says to wave the phone in a figure eight, decided from the spread of the last two seconds of readings rather than from hope. If the phone has no compass at all it says so plainly instead of pointing somewhere.

One extra key: Save heading writes the job a note — facing west, 271 degrees, the coordinates, the time. It is the same note the Note key writes, so it lands in the gallery under today and the connector reads it like any other.

So words are asked for separately now, because they live under a different rule than photographs — no media, and a day they are pinned to instead of a street they were taken on. They come back as their own kind and the gallery draws them as LINES under that day's heading, never as tiles. That is law 3, bought with real pain last month: a photograph belongs in a square and a sentence does not. A note prints every word it has, right there on the surface, with its clock and one way to take it back.

Two smaller things went in with it. A note now lands on the page the moment you save it, instead of waiting for the next reload, and it carries the fix from your pocket the way a photo does — where and when, on everything. And the search field reads notes too, so a word you typed on Tuesday finds the day you typed it.

The feed carries clips as their own kind with a url, never a picture; the tile is the browser's own first frame with a play mark; the viewer plays it inline with the phone's controls, its note beside it, editable. No Full size on a clip — the file is the file.

A walk is a tile like a photo: the feed carries every walk on the owner's jobs as a tile whose picture is the shelf's tenth second once cut (the box's live sample before that), a dark tile with the box's word — Stitching, Cutting frames · 40% — until then, and Watch the walk once there is footage. No note editing or moving on a walk; the box owns it. Shifts are not walks and a discarded walk stays out.

Two answers to his questions. The dropdown stays the phone's own: it opens as a native sheet, scrolls fast, and nearest-first already does the sorting — an in-app list would only earn its place if it ever needed search inside it or cover photos. The job row stays at the top and scrolls away: it is read once, the belt at the foot is what is pressed, and unsticking it gives back a row of photos.

The foot law still holds: the bar's own padding is the FOOT clearance (52 px or the safe inset), so no key ever rests in the strip Android's nav bar eats — the pain that wrote the law. The spec measures every key of the belt against that strip at the phone's height.

"Make Photo and Note clearer." They looked faded because on All jobs they were disabled. They are never dimmed now: on All jobs a press asks which job in one inline row (nearest first) and then shoots or writes; on a job they act at once. Add to Home Screen is the ink key of the ⋯ row.

The icon is redrawn: a heavier T optically centred inside the maskable safe zone, the orange dot as its period; the tab sizes drop the dot, which was two pixels of noise at 16 px. Icon URLs are v4 so every browser refetches.

The root layout still opened a connection to Google's tile host on every page — a handshake for a world that was deleted in August. Gone. The photos route imports its client once at module load instead of inside every request, and a failed read's ledger row now names whose read it was.

The foot's timing split double-counted on a one-job read (both numbers took the same wait, so the Neon wake was blamed on the photo query — the very number the ledger is read for); each hop stamps its own duration now. The viewer held a position, and when the live list landed with a newer photo on top the open picture silently became someone else — it holds the photo's id now. A remembered job that no longer exists falls back to All even on an account with no jobs, and deleting or merging the held job forgets it. The whole-record feed's poorer job list (names in capitals, no fixes) no longer overwrites the real one. Signing out forgets the gallery's copies on the device.

And the 0.7 s of the read that is the photo query, for which the index is still Kymani's to apply: the query asked for sixteen jobs at once and the database scanned and sorted all their rows in one process. It asks each job separately now, sixteen at a time, each a sixteenth of the sort, merged newest-first on the way back — no index needed for that half of the saving.

The icons: a browser keeps a site's favicon by URL for a long time, so the new files at the old paths kept showing the old picture. Every icon URL carries ?v=3 now; the old shortcut on a home screen still has to be removed and added again.

That 0.7 s is the photo query itself and is the index migration waiting to be applied; the rest of the read is small.

So the shop box pays the wake instead of a phone on site: worker.py pings /api/warm every four minutes with its own bearer, and the route runs one select 1 through Prisma. The box pulls main and re-execs itself between jobs, so this lands at the shop without hands. No ledger row — a heartbeat is not a tool call. If the Neon console is ever set to stay awake, the ping is harmless.

The job list lives on Neon and the photos on Supabase, and the photos could not be asked for until Neon had answered. When one job is asked for, its photos are now fetched while the ownership check runs and released only once the job proves the owner's — the law holds, the Neon wake no longer stands in front of the pictures.

The first twelve thumbnails leave the phone the instant the grid commits (eager, high priority); the rest wait to be near. A read that a newer job pick has overtaken never paints over it. The viewer opens instantly on the 256-pixel thumb the phone already holds and the 1080 sharpens over it when it lands. Hashed build files are cache-first in the service worker (a new build is new URLs; re-validating thirteen of them shared the radio with the first pictures). The two fonts the gallery never draws stop preloading, Leaflet's dead stylesheet is gone from the render-blocking CSS, and a new photo is uploaded with a year's cache age.

Prisma's connect timeout is fifteen seconds instead of five (added to DATABASE_URL in code unless the URL already says): Neon's compute sleeps after five idle minutes and a wake slower than five seconds threw P1001, a 500, and the gallery onto the whole-record feed with nothing saying why. Still Kymani's to turn off in the Neon console.

The photo query asks for a second page only when the first came back full; three unconditional pages each re-sorted the owner's rows and two returned nothing for a record under a thousand photos.

The phone's own copies of the thumbnails and the map tiles were named with the service worker's version and wiped on every deploy by the watchdog — several times a day this week — so each next open re-fetched every picture. They are unversioned now and the watchdog purges only the code caches.

The HTML document, /sw.js, /manifest.json and the version poll each ran a Supabase Auth round trip in the middleware whose answer decided nothing (the protected prefixes name routes that no longer exist); the check runs only for /login and those prefixes now. AuthProvider moved from the root layout to /field, its one reader — on the gallery it shipped a third of the JavaScript and ran a profiles query nothing drew. /api/version answers from the edge.

The grid did n² work per tile (findIndex) and one date formatting per photo; a Map and one word per day now, and off-screen spots are skipped by the browser (content-visibility). A failed lean read is a gallery.read row with ok:false and its error, and the foot says 'via the whole record' when the days feed stood in.

Waiting on Kymani's hands, said plainly: pwa/supabase/migrations/20260918_captures_gallery.sql (an index on (project_id, captured_at) and the gallery's own partial index — apply in the Supabase SQL editor after reading pg_indexes); Neon's compute scales to zero after five idle minutes and every first open pays its wake (Neon console: turn scale-to-zero off or lengthen it, and add connect_timeout=15 to DATABASE_URL on Vercel); Supabase's JWT signing key rotated to asymmetric would let every route verify the session locally (getClaims) instead of one Auth round trip per call.

"Seven seconds… check the ledger." Nothing on the box can be measured from where this session runs, so the app measures itself: /api/sites/photos times its three hops — the session check (Supabase Auth), the job list (Prisma on Neon), the photos (Supabase) — and hands the numbers back in the body, in a Server-Timing header, and as one gallery.read row in the ledger. The gallery's foot prints them: read in 6.8 s · session 0.3 · jobs 4.1 · photos 0.9 · start 1.5 — the last number is what the server did not account for: a cold function, the network. The slow hop is read off the record from here on, never guessed.

One round trip cut for certain: the middleware ran updateSession (a call to Supabase Auth) in front of every /api request, and every route then checked the session again itself. API calls skip the middleware's check now; the refresh and the redirects are for documents.

THE BOOT CHAIN, CUT: the gallery used to ask /api/sites first — a route that counts every job's photos and papers, walks every fix in the record for the map pins, picks a cover per job, reverse-geocodes, ten queries deep — and could not read a single photo until it answered. Now the job is decided before any network (the link's ?job=, else the last one held, else All), the phone's copy of the job list and the photos paint at once, and ONE request to /api/sites/photos brings the jobs and the photographs back. The whole-record route is never asked by the gallery again.

tests/gallery.spec.ts pins it: one feed, the cached paint beats a 4-second network, signed out says so, the days feed stands in when the lean one fails, a remembered job that no longer exists falls back to All without a loop.

TIME: the gallery was reading /api/sites/days — up to four thousand rows of every kind, thirty note keys each, plus every walk, shift and day header — and keeping only the photographs. /api/sites/photos is the gallery's own feed: the database hands back only rows with a picture (never a frame the box cut from a video, never a worker's frame, never a paper, a clip, a day or a brief) and only the eight keys a photo on the gallery wears. If that feed ever fails the old one stands in, because slow beats empty.

SPACE: the sticky header was five rows — the job row with three keys, Photo and Note, the search field, the count with its links, the install key — on a phone that was half the screen before the first photo. Now it is two: the job with one Jobs key (New / Rename / Delete fold under it) and Photo · Note · Search on one line. The count, the Work / History / 360 video links and Add to Home Screen sit at the foot of the page.

ONE: the Add to Home Screen key now puts the app on the screen with its own icon instead of printing how to use Chrome's menu. Chrome hands a page exactly one install offer, usually before the gallery had mounted its key, so the offer was slipping past unheard and the key fell through to the text. The layout's first script now banks that offer the instant it lands (window.__tmInstall), the manifest carries an id so Chrome treats every path as the same app, and the key waits a beat for the offer before it ever says anything. The new icon ships with it — an old home-screen shortcut keeps the icon it was made with, so remove that one and add it again.

TWO: the app no longer detects job sites. ARRIVING HOLDS (2026-09-06 — standing within 150 m of a job silently held it) is deleted from Field, and the job line no longer says "at X · Hold" for another job's ground; the job you hold changes only by your own press. Kymani: "treat it like Google — users can create folders if they want to", and "trade depends on your temporal geographic memory", so every photo and note still carries where and when it was taken, and the gallery's job list puts the nearest jobs first from one quiet fix. Nothing decides for you; the ground just sorts the list.

The viewer: tap a photo and it fills the screen; swipe left or right to walk every photo on the job in the page's order, swipe down or ✕ to close, tap to hide the words. The note is there, editable. This is the phone-gallery motion he asked for — "rapid succession" — in place of grow-in-place.

The job row: New starts a job by name where you stand; Delete removes an empty job at once, and for a job that holds photos it keeps his own 2026-09-06 law ("this data is important so can't delete") — it says how much the job holds and moves everything into another job before the empty one goes.

And an Add to Home Screen key on the gallery: Android fires its own install prompt from it; iOS never offers one, so the key prints the two presses. It disappears once the page runs as an installed app.

Same day, two more: All jobs is the dropdown's first and default item — one gallery of everything, each spot wearing its job's name, the search finding job names too (Photo and Note wait for a job to be picked); and the viewer's swipe follows the finger — the previous, current and next photos ride on one track that slides with the drag and snaps on release, a flick turns the page, a pull down closes.

Rename joined New and Delete on the job row. And the home-screen icon: the two PNGs the manifest named turned out to be base64 text that was never decoded, so every Add to Home Screen ever done got a blank tile. Drawn fresh with geometry, no font — an ink square, a heavy white T, one orange dot under it for where it was taken — at every size the tab, Android and iPhone ask for; the manifest is white paper now, like the app.

On All jobs a header read "Bethesda Purple Poles · 8270 Greensboro Drive, Tysons" — not a bug, a misfile: the phone was still holding the last job when the shot was taken at the next one, and the gallery prints both the job a photo is filed to and the street it was taken on, so a misfile shows itself. The viewer now carries Move to another job — the same move the History row has.

What a phone gallery cannot do and this one does: it knows the job, it knows the street, and the note is bonded to the photo — tap a photo and the note is there, add one if it has none. That is the whole product; the walks, the shift camera, the connector and the day map are ways to put more photos and notes into it.

The photographs' contact sheet is the one square the History law allows; words stay out of it — a white dot marks a photo that carries a note, and the note prints in full only when the photo is grown.

Why a page and not a Claude project: Claude cannot take a 360 video — a project refuses a 2 GB .insv, and a small mp4 gets sampled, not read every second. Tradesman is where the video goes in; Claude is where every question is asked. The demo's step-by-step turns confused him, so said plainly here: Sergio types one question and Claude makes every tool call itself inside that one turn.

Added before it went live: the three steps printed on the page — Connect, Upload, Ask — each turning green as it is done, and step one in full: the connector's address with a Copy key and the three presses in Claude, shown until the ledger has seen this person's Claude read the record.

On a new phone the page met an account with no job and said go start one in the app — a wall on a page meant to be impossible to mess up. The first upload now starts the job itself from the phone's fix, exactly as Start a job does; with no fix it files anyway and the job can be renamed in the app.

The second is the second: ffmpeg's fps filter after a seek handed frame 5 back as t=5.4, measured on a clip with the clock painted into every frame; a select filter behind a keyframe seek is exact. The four face directions are pinned by a painted-pano test (video_faces_test.py) — the first draft had up and down swapped, and only a wrap in y made one look right. An .insv is stitched a second time at 4096 wide for the shelf, because a 90° face cut from the 2304 watchable preview is 576 px. Killed mid-video, the box resumes at the segment it was on.

The connector serves the shelf: tradesman_video_status, tradesman_video_timeline (which seconds a Claude has described, and a word search over them), tradesman_video_frames (a batch of pictures, next_t when cut — your Claude walks the whole video chunk by chunk, on your plan), tradesman_video_frame (one second at full quality for a breaker label), and the third write, tradesman_record_frame — what your Claude saw in a second goes back into the record as the same walk-frame row the box's indexer used to write, so the next question on that video is fast and /watch?at= still opens the proof. tests/mcp.spec.ts names all thirteen tools and the three writes.

On the phone: an .insv picked through UPLOAD used to file as a paper; it is a 360 walk now, rides the camera's own rails to the box, and the day's History row prints the shelf's word. Not built, said plainly: a resumable upload for a 20 GB file (a dropped connection still restarts the PUT), a push on ready (the WebView has no Push API), and the FTS migration (20260916_captures_fts.sql) waits for Kymani to apply it — the timeline's search falls back to an in-memory pass until then.

What exists: the whole road is already walked thinly — X5 upload to R2, the box stitches (Insta360 SDK, v360 fallback), indexer.py reads frames into captures rows that ASK, /watch?at= and the MCP already understand. What does not exist: coverage (180 frames per walk, not every second), previous-frame context, rollups beyond a 7-word caption, any FTS or vector index (ASK stuffs up to 3,500 lines into the prompt behind a .limit(1500)), a resumable upload for a picked file, a per-video status.

Recommendations waiting on his yes: the shop box is the long-running worker (it has ffmpeg with v360, the licensed SDK, the GPU and the lease/retry skeleton); extend captures.ai_notes rather than adding videos/frames/rollups tables; a 4096+ index master because a 90° face out of the 2304 preview is 576 px; FTS + a rollup ladder before any embedding vendor; Sonnet 5 per second and Opus 5 for rollups. The cost of full coverage is written down plainly: ~28,000 calls and ~160 M input tokens per 6-hour video.

CLAUDE.md's paragraphs the PRD named are amended in place, the superseded text marked HISTORY rather than deleted where the pain it recorded still binds: voice is input and output on the line, never a pipeline; the apprentice is the one model surface the app owns; the belt has a third hand in lib/skills.ts; the tracker paragraph records the Beacon's deletion and the two leaks closed; the box paragraph says what was actually running on 2026-09-14 — two tasks, one of them self-updating from the dev tree; the day paragraph is finished through Phase 5. TOOLS.md gains the day and the apprentice's doors, the two voice devices, and a route count read from the tree (58). APPRENTICE.md §18 is the build log: every phase's commit, every deviation from the plan and why, and what waits on Kymani — 6a, 6b, the APK and its hot tests, the box.

The turn route names each picture for what it is, files the window as a window and the phone's equirect as the sphere, and the exchange row remembers where the window pointed. The box's eye is sent only when the phone has no sphere up (an older APK, or the eye not yet open). tests/eye-stitch.spec.ts measures the phone's equirect of the real raw frame against the box's stitch of the same frame — mean difference under ten levels — and checks the window is a lit square whose centre is the strip's centre.

GET /api/day?id=&gpx=1 is the day as GPX 1.1 — one track segment per span (a pause is a gap), one point per banked fix with its time, and one waypoint per record with its time, its words and a link back to the row. The office opens it in Google Earth; every running app reads it. No key in the app for it yet — the PRD calls the export late, and the door is enough for the office.

WHERE is words too: a placed row prints its street once it has one, else "330 ft N of the job's door" from the site's own fix, and only a row with neither prints raw coordinates — the digest line, which every night worker reads, never does; it was WHERE-blind by construction. The job's header tells the model how many days the job has been worked and which day today is.

The ask windows are built in the asker's zone, and the parts of a day are hour windows: "this morning" is 4 to noon, "this afternoon" noon to six, "tonight" from five — not the whole of today. The shift's debrief lists what was SAID on site beside its frames ([S#] clock · he said / it said — his own words are evidence, the reply is context), and the connector's day reads an exchange the same way. tests/when.spec.ts pins the zones, the windows, the street, the bearing and HE SAID / IT SAID.

Speaking is a toggle on the pill, remembered on the phone; a spoken turn is always spoken back. The WebView disables the browser's own speech, so the APK speaks through Android's text-to-speech (@capacitor-community/text-to-speech, on-device, no permission) — imported in exactly one file, lib/ledger-phone, behind the ledger wrap, so one tts.speak row lands per reply and one speech.listen row per utterance. tests/ledger.spec.ts now fails a second import of the package and any file that names a recogniser without writing a row. Holding the mic stops any speech; the mouth is silent from the Connect press until the camera answers (the one measured SDK audio conflict is at openCamera).

Nothing ever asked for the microphone: the Web Speech API raises no permission request of its own, and the 2026-08-31 proof ran on a grant a deleted plugin had left on Kymani's phone. The bridge gains a RECORD_AUDIO alias and askMic; the pill asks once, on the first hold, and prints one line under itself if refused. Prove it on a CLEAN install.

The native leaks named in the PRD are closed in the same APK: the live eye's vision executor is per open (a static one, shut down by the first shift's close, silently never ran the person model again); the window cut at full resolution is one immutable holder stamped with its frame's clock; the blinking-light Beacon and its DFT are deleted with the beacon numbers in the live ping (Kymani, on a worn beacon: "no"); StepSense stops on every camera stop path, whether or not the day keeps the service alive. Java compiles against the Studio JBR. The APK build and the hot tests — STT with the camera off on a clean install, then TTS, then a Connect with TTS mid-sentence — are Kymani's.

The closed line carries the day's path as a glyph — ink on paper, never a tile — and its numbers: 3 h 12 min · 2.4 mi · 14 records. On Every job, a date with several jobs prints each job's own glyph and numbers above the map.

The day's row (kind day) reaches History as the day's HEADER, never as a row: the days feed ships its status, spans, metres, moving time, the glyph's path (at most 120 points), the stop count and the shifts that joined — never the path itself and never the key. The shift item now carries where the camera stood. A day recorded before the path existed draws the connect-the-records line the share window drew, dashed, and says no path was recorded.

The stop math survives as the source of the streets on the map and the stop count. The strip, the note lines under it and the word rows are gone from the open day. tests/field.spec.ts pins the map, the glyph, the numbers, the slot and the honest rows; a GPU-drawn mark cannot be pressed by a test, so the map frame answers a tm:pick event with the record's id — the same door the mark's card presses.

WORK is the day. The picture takes every pixel between the tab row and the deck: the one map of today's marks, or the camera's eye when one is out, with everything about the day riding ON it — the numbers top-left (DAY ON · 1 h 03 min · 0.8 mi · 5 records), Map | Eye top-right, the worker's last answer or the open Note card above the belt, and the belt itself along the lower edge (Note · Photo · Clip · Upload · More). Under it, two things: one pill to talk to the worker — hold the mic or type; every turn carries where you stand and your zone — and one row of four round keys: Start · Pause · End · Camera.

Every key is always on the glass (his fifth verdict: "all buttons visible — disable them with states if you need to"). The set never changes; a key that does not apply is dimmed. The ink key is the next act: Start, then Pause, then Resume. The camera is a sensor (his seventh: "you shouldn't be able to start the camera independently"): its key connects and disconnects, never starts; Start the day starts a ready camera, End the day ends it, a camera coming ready mid-day joins the running day. Pause is the person's — the tower keeps filming. A shift on the clock or developing with no screen mounted still shows on the camera key, and the key opens it.

The day itself: Start posts its row and hands the phone's day service its id and key; the service's pocket fix feeds every note, task and photograph its WHERE. Without the service (a browser, the APK before the next build) the web banks its own fixes while the screen is on. A reload walks back into a running day.

The worker's screen renders only the eye now; the link form, a lost camera and the keep question are cards over its own picture. History is unchanged in body, no fold; its "N in M days" rides under the History tab. tests/day-front.spec.ts (a fake day service installed before the app mounts) and the rewritten tests/field.spec.ts pin all of it.

/api/day: start (a reload never inserts a second day; Start on a done day reopens it with a new span), path (keyed — the whole path replaced, the numbers recomputed), join, end (the offline fallback), and GET. lib/day.ts is the one encoder: every fix is stored, and the gates — a fix worse than 30 m is not a step, under 3 m is jitter, over 8 m/s is a glitch — apply only when measuring, so a standing hour adds nothing. tests/day.spec.ts pins the wire and the gates on a walk that is easy to reason about.

The native day service lives in WalkRelayService beside the relay, with its own statics: Start takes a location-typed foreground service and its own 14-hour wake lock, never opens the camera, banks every fix to disk with the fix's own clock, posts the whole path every ten minutes and on pause, resume and end (the final post retries until it lands), and survives a kill from day.json. ONE location listener serves the day and the relay's live ping (fused from Android 12, else GPS, else the network — checked, never assumed; a refused permission is visible, never a day of zero points). The foreground type is a function of state on every transition, and every camera stop path is guarded so a running day keeps the service. Five bridge doors: startDay, pauseDay, resumeDay, endDay, getDayStatus (polled, never a ledger row a poll).

Needs the APK to be rebuilt; until then the web keeps the day itself while the screen is on.

ONE Messages call, thinking off, strict tools: photograph / note / task / panel / code are executed and answered from their says-back line with no second call; only recall (the record through /api/ask) continues the loop, once. The exchange lands as a row of kind talk — his words, its words, what it filed, the proof — and the ledger row is awaited before the answer goes back, because a serverless function is frozen the instant it answers.

History reads an exchange as TALK: his words in ink, its words in soft, "via the worker" beside a row the apprentice filed; a day counts its exchanges. The record's query engine reads a said-line as evidence for HE SAID and context for IT SAID.

/api/worker/ask is deleted — it answered from one frame with no memory. The worker's typed line now speaks to the turn route; it moves onto the Work screen with the day in Phase D1.

Also, ahead of the day: every reader of the record (ASK's pool, the night clerk, the code reader, the connector, the days feed, the live window) skips the day row that Phase D1 introduces, so a path never prints as a note.

The shift's strip reads the same rule: only the rig's frames enter it, so an on-request photograph prints once on its day, never twice.

day-notes and open-items copy gps and tz into the row verbatim when the body carries them and never refuse a body without them. A note the apprentice files on the spot (`live: true`) keeps its own clock in History instead of the day's noon; a hand-pinned note still sits at noon.

History says "via the worker" beside a row the apprentice filed, the way it says "via Claude" beside one the connector wrote. tests/field.spec.ts pins the anchor on a task written in History with a fix on the phone.

The connector's two writes (tradesman_add_note, tradesman_add_task) now go through the belt; their sentences are unchanged. A note written from a desk while a shift is on carries the camera's last fix, so History can still say where.

The Photo key on the worker used to file a bare row through /api/sites/photo — no fix, no words, no ownership check on that route, and Vercel's body cap. It files through /api/apprentice/photo now with "Kept by hand", the fix, the zone and the shift — and no `from`, because a photo you kept yourself must never print "via the worker".

page.tsx keeps the fix's own timestamp on userLoc, so a cached fix is filed WITH its age, never as fresh. tests/shift.spec.ts pins the anchor on the Photo key's POST.

APPRENTICE.md is the build — Part I the apprentice, Part II the day — with his nine verdicts on the mock folded in: the map is the table, one shape in every state, every key always on the glass, the camera is a sensor with no Start of its own, the map fills the Work screen, Work and History are two full screens behind one tab row.

Phase 0, two safe fixes: getLiveTarget joins the ledger's POLLED set (WorkerShift polls it ten times a second on the clock and every poll had been a row — 4,374 of them on the live table), and the phone rig's ?a=open accepts the timelapse kind it has been summoning since 2026-09-06.

CLAUDE.md's tracker paragraph described the 09-07 rollback and not the 09-08 native follower that came back on his word; it now describes the tree — Beacon, PersonCheck, HiVisFollower in LiveEye.java, StepSense, lib/anchor.ts, and who wins when.

Nothing new was invented. `lib/download.ts` has known how to save a file since the card era (August 17) and had been orphaned since the machine was deleted: the installed app streams the bytes straight into Documents through the Filesystem plugin already in the APK, a browser hands the URL to its own downloader with Supabase's `?download=` attachment header. No blob in JavaScript, no new build.

Where it lives: press a picture in History so it grows, and beside Smaller there is now Save. Photos, 360 stills, clips, and a shift's kept frames all carry it — it is one prop on the picture cell, so every surface that grows a picture got it at once. The saved file is named for the job and the moment (`redland-crabbs-2026-09-02-151000.jpg`), never the bucket's number, so a folder of them sorts into the order the work happened.

The key says where it went in its own words for a few seconds — "Photo saved to Documents." — in place, never a toast or a dialog. A silent success on a phone reads as a dead button. `tests/field.spec.ts` pins the key, the name and the download.

The answer the best photo and jobsite apps landed on: everything in a record is either something you LOOK AT or something you READ. Pictures go in a strip, words go on a line, and the kind of record becomes a small label instead of its own layout. The eye scans one axis, time, and never relearns the page per row.

The shift row broke that. It was six sections inlined into one row: the numbers, the keep keys, one bar per worker, who was here, the debrief, and the pressed moment at the bottom. A page pretending to be a row, and one you could not even close.

Now a shift is ONE LINE (the lane, how long it stood, how many frames, how many people, Keep and Discard at the end), where it stood, ONE STRIP of its frames that scrolls sideways with the film as its first cell, so a 40-frame shift and a 400-frame shift are the same height, and its debrief as a read-line like any note. Press a frame and it grows under the strip, the film playing from that second when the shift has one. The lane bars are gone.

This is deliberately not a positioning system. A phone in a pocket does not know which way it faces relative to the body it is in, and a steel-framed shop ruins the compass, so alone it is worth thirty to forty-five degrees and no more — I had quoted ten to twenty earlier and that was an overclaim. What saves it is the shape of the problem. A 360 camera has no frame edge, so losing him never means he walked out of shot, only that something is standing between him and the lens, and that lasts seconds. Over ten seconds a phone's yaw drifts a couple of degrees. Vision holds him most of the time; his own steps carry the mark across the holes.

It teaches itself the one thing nobody can measure. Each time the camera sees him again, where he actually is gets compared with where his steps said he would be, and the rotation between those two answers is how the phone sits on him and which way the camera points, both at once. Neither is ever asked for.

The fusion lives in TypeScript, not buried in Java where the last two trackers went to die untested, and a bench test walks a man around a camera, blinds it for eight seconds and demands the mark still be within ten degrees of him. It caught two real bugs on the first run: a walk was being treated as one straight chord when a man circling a camera six metres away sweeps ninety degrees in eight seconds, and the pocket offset never learned because fixes arrive so often that the walk between them is centimetres. Steps come from the raw accelerometer rather than the platform step counter, so it asks for no new permission, and yaw comes from the game rotation vector with the magnetometer deliberately left out.

The cause was one test: a photo got a line when it carried a note OR a label. A photo's label is never empty — the wire falls back to the eye's summary, and then to the clock and the word PHOTO — so the test was true for every photo in the record, and the strip was followed by itself, one row at a time.

Now a photo is a cell in the strip, full stop. A line under the strip exists only for a photo that carries a note a person wrote — the bonded pair, and nothing else. The white dot on a cell means the same thing. The field spec carries a no-note photo beside the noted one and fails if it ever gets a row again.

The numbers said the same thing from the other side. On his own shop shifts the phone found him in 45% of frames and the box's far stronger model on a CUDA GPU managed between 50 and 89. Neither is a life-safety number, and no amount of tuning was going to produce one, because asking a camera to RECOGNISE a human is the hard unreliable problem. So he stops being something to recognise and becomes something to DETECT.

He wears a blinking light. The camera runs at thirty frames a second, so every block of the frame can be asked one question: is your brightness oscillating at the beacon's rate? A wall cannot, a vest cannot, a bucket of vests cannot. Everything that really moves in a shop lives below about five hertz, so a light pulsing at fifteen sits in a band of its own. There is no model in this at all — one sliding single-bin transform per block, four multiplies a frame, and it is exact.

It was measured before a line of the Java was written, by injecting a light into his camera's own frames at the size it would have at each distance: found from two metres to sixty with a twelve to thirty-five times margin over the next best block, and sixty-five to a hundred and twenty times once the sequence has been through the relay's real H.264 at 8 Mbps, because the codec strips the noise and leaves the beacon standing. Three frequencies are searched at once, so any flashing light works — a bike tail light, a work strobe, or the phone's own torch. The vision follower stays underneath for anyone not wearing one.

It answered in one pass, on the two shifts that failed. A phantom body sits at the bottom-left of nearly every frame — a skeleton the model is sure of, stationary, never wearing anything bright — so the pose model alone was never going to fix this. And he is only detected in about forty-five percent of frames, which means on every frame that missed him the rule still locked the best body present. That was the phantom. That is the box on the furniture he kept seeing.

The same measurement settled what the vest is actually for. Across those frames he scored 0.29 to 0.78 and the phantom 0.00 to 0.09, so as a way of CHOOSING between real bodies the colour separates cleanly; it was only hopeless as a way of FINDING them. Nothing is locked now unless it is a body AND it is wearing hi-vis, and when he is missed the marker says nobody in a vest, which is the honest answer. Once he is held the vest is not asked for again — the model and his last position carry him through a turn or a shadow.

The trade is stated plainly: a worker with no vest is never acquired. That is deliberate. A quiet marker beats a confident box on a chair.

So the day is the fold now. At rest every day is one line: its name, what it holds ("12 photos · 1 shift · 1 note"), and the streets it happened on. Days sit under Today, Yesterday, This week, Last week, then the month. Every day starts closed, one is open at a time, and a search or a filter opens the first day it hits so a match is never hiding behind a fold. The day you had open survives a deploy reload with your search.

An open day is not a list of records any more. It is read as STOPS: the phone stood somewhere, and everything filed standing there is one block — the street once on top with its clock span, every picture taken there in one contact strip, the pictures that carry words as lines under the strip with a small thumb beside each (the bonded pair, kept), and anything written there as a compact line. A record with no fix is about the job, not a spot; it keeps its own row with its own honest where. A picture still grows in place under its strip, with its clock and its words, and shrinks — nothing opens, nothing pops.

The effective change underneath is in how the address is fetched. It used to be asked per photo as each row came near the screen. Now the street is asked ONCE PER STOP: a collapsed day coming near the screen asks for one member of each nameless stop, the answer is written to that row for good, and the rest of the stop reads it from its neighbour. A day of forty photos at two spots is two geocodes, not forty, and a stop whose ground had no name is never asked again.

Law 4 in CLAUDE.md is amended, not repealed: the record still has no page for a data point. The DAY folds; the record does not.

EfficientDet is a generic eighty-class object detector. On a warped fisheye crop of a cluttered desk it will call a chair with a jacket on it a person at half confidence, and no threshold fixes that, because the model does not know what a body IS. It is now a POSE model: it has to return shoulders, hips, a head and limbs, each with a visibility score. The test is the one the box's own pipeline has always used — both shoulders and at least one hip clearly seen, shoulders above hips, at least eight joints visible. A heap of hi-vis fails every part of it. The vest is then read on the torso the skeleton itself reported, not on a guess from a bounding box.

The marker was also being drawn as a bar the full height of the frame. Its angular height is carried in units of pi and was being fed to tan() as though it were already a half angle, so a normal body read as forty degrees of view. Sized off the span now, and capped so a person can never fill the glass.

That is the design being inverted, and no threshold could ever have fixed it. It looked for bright blobs and then asked the model whether any of them was a person — so the model never saw anything that was not already bright, and among bright things the nearest and biggest wins. A bucket of vests beats a man across the room every single time.

It now runs the other way round. The person model sweeps the frame in eight overlapping tiles and returns the BODIES it finds; a bucket, a chair and a hanging jacket are not bodies and never enter the running. Only then is colour used, and only to choose which body is his: the vest is scored inside each person's own torso and the wearer wins, with the nearest body taken when no one is wearing one. Colour can no longer invent a person, only pick between real ones.

The cost stays where it belongs. The sweep runs on the vision thread about twice a second and only while nobody is held; once a body is locked, a single crop re-confirms him about once a second, and the cheap colour window follows his torso on every decoded frame in between.

So the eye now keeps its own account and sends it with the live ping it already makes every few seconds: whether the person model came up at all, how many crops it was asked about, how many held a body, how long one inference takes, and what the follower last decided. It lands in the shift row as stats.live_eye. After any shift, from anywhere, the record says plainly whether the phone's model is the problem or the box's drift is.

And discard now means stop. It used to only delete: the box was still developing at that moment, so it went on stitching the film, reading frames and writing a debrief for a shift already thrown away, and whatever it wrote after the delete stayed behind. The box has always had a stop-now path — it drops every chunk and banks nothing the moment a job reads failed — and discard simply never used it.

So the failure is distance, not identity: a body near the lens is held perfectly, a body across the bay is lost to clutter. One narrow rule goes in from that evidence — a detection that is both SMALL and HIGH on the wall is not a person. The camera stands near eye height, so the horizon is halfway down the strip and a standing body's torso is below it; something small above that line is a light fitting or a joist. It stays loose enough that a man on a ladder still counts.

Also learned the hard way while reading it: the film runs one frame every two seconds, so it does NOT span the shift evenly. An overlay that assumed it did put every box at the wrong moment and nearly produced a confident wrong conclusion.

The shift loop now asks. A job that is gone from the record is let go, its chunks dropped, and the box goes back to polling. The check is deliberately narrow: gone means a clean 200 carrying no rows, seen twice about thirty seconds apart. A timeout, a 5xx or a degraded gateway is never 'gone', so the outage we just lived through could not have ended a real shift.

It cannot become the trap End used to be. The shift has ALREADY ended before the question appears — the record was told first, over its own keepalive post — so every key here is instant and none of them waits on the camera. Later simply leaves it kept; the same Keep and Discard live on the shift's row in History either way. Discard removes every file the shift wrote and every frame it filed, and the shift stays in History as a fact that happened with nothing kept from it.

The reason was in the data, not the model: his blob was SIXTH by size, and the code only ever asked the model about the two biggest candidates. The vests draped near the lens are always bigger than a man across the room, so he could never win that ranking. The model is now shown the blob it has looked at least recently, so every candidate in the room is asked within about a second whatever its size, and it is asked five times a second while nobody is held.

The score bar came down from 0.50 to 0.40, measured: at 0.50 he was rejected at the desk while every piece of furniture was already thrown out by the two rules that actually discriminate — the body must not be a sliver of its crop, and it must contain the blob that proposed it.

Nothing is awaited now. The record hears it FIRST: one small POST, keepalive so it survives the screen going away, and the shift is stamped ended before a single camera call is made. The screen leaves immediately; there is no 'stopping' state left to be trapped in. The teardown runs behind you under a twelve second ceiling and submits the true chunk count when it finishes.

The count is now a separate fact from the ending. The box uses live_final_count as how many chunks to expect, so stamping a zero on every End could have truncated a real shift; it is only written when the count is actually known. Without it the box still closes the shift on its own silence rule. And End is offered whenever a shift is on the clock, including from another device, since the server checks who owns it.

The model now runs on its own low-priority thread, is handed a copy of the frame, and is skipped outright whenever it is still busy. The decode thread keeps only the cheap windowed follow, which can never block: it takes the lock or gives up on that frame. A check that cannot be dispatched no longer costs a 5 MB frame conversion either — while the model is busy that frame goes to the cheap follow instead.

Two other wastes went with it. The eye was compressing ten JPEGs a second while the monitor only read five, so half of them were made and thrown away; it now makes five, and the FOLLOW keeps running on every frame regardless, off that clock. And the windowed follow is capped at about 3,600 samples however close the body is, so a man filling the frame costs the same as one across the bay.

The gate got stricter for a reason the screenshots showed. The camera is carried, so when it moves every static thing in the room moves with it — which let the old fallback follow a draped vest as though it were walking. Colour can no longer START a lock at all; it can only carry a body the model confirmed in the last four seconds through a gap in its sight. The model's own score threshold went from 0.30 to 0.50, a body that is a sliver of its crop is thrown out, and the body the model finds must actually contain the blob that proposed it — a wide crop around a chair could otherwise inherit the confirmation of a real person standing beyond it.

Now the body is followed on EVERY frame the decoder hands over, about thirty a second, by sampling the decoder's own planes inside a window around him — no copy of the frame, no JPEG, no model. The expensive things keep their own slower clocks: the picture every 100 ms, the person model about once a second, and only those frames pay for a full NV21 conversion.

The marker also got its own bridge door. The eye's picture is ~70 KB of base64 and is worth reading a few times a second; the target is five numbers and is now read fifteen times a second. End to end the marker is one frame plus one poll behind him, tens of milliseconds.

The methodology, not just the model: colour only PROPOSES. Each proposal's own crop of the frame is shown to the model at full resolution — never the whole dual fisheye, where a man five metres out is a dozen pixels after the model's resize — and only a crop containing a body may be locked. The box that is published is the MODEL'S box. A lock is re-checked about once a second and dropped after three failures, so a walk past a rack cannot stick to it.

Measured on Kymani's own screenshots before shipping: in the frame where he sits at the desk with a vest hanging on a chair to his right, the gate accepted him (twice, 0.48–0.56) and rejected the hanging vest — the exact failure he reported. At the far end of the bay, at the preview's resolution, it found nobody, so there is a second tier: a hi-vis blob that is MOVING may be followed unconfirmed and says so. Furniture can never take that tier — a flag, a rack and a bin do not move.

Two fixes. The tracker keeps a slow background of the strip and publishes a body only once its box has changed the picture beyond what the whole frame did — a garment on a chair never does; replayed, nothing is published for the first eight seconds and from the moment he walks in the box is him. And the row now carries each body's heading and the clock its word was read at; the phone polls every 1.5 s while following, reckons the marker forward by that age (four seconds at most) and says "the box's word is N s behind" when it is.

Now following is on from the start: the moment the box sees someone, the view glides to them. Dragging the sphere pauses it; the key turns it back on. The mark is a box the size of the body itself — the box reports how tall you are in the frame, and the sphere draws exactly that, orange in a vest.

Verified by screenshot before pushing this time: a near vest-wearer in front fills a body-sized orange box; a far plain person behind the camera gets a small white box and the view turns to them. scripts/eye-shot.mjs takes those pictures against the e2e eye page.

All of it is deleted: both tracking libraries, the Haiku call that named a touched thing, the telemetry route, Follow me, touch-to-follow, the MediaPipe dependency, their tests. The eye is a plain 360 sphere again: the GPU stitch, drag to look, frames swapped in place.

Tracking did not go away — it moved to where it already worked. The shop box tracks every person on site with the full frame and the GPU (it held Kymani through his whole recorded walk with one unbroken id). The phone now reads the box's word off the job row and draws one quiet ring per person on the sphere, orange for a vest. A Follow key glides the view to the first of them and never zooms. The line under the eye says 'One person in a vest', '3 people', or 'Nobody in sight'.

Rule written into CLAUDE.md: do not put a tracker back on the phone. A better follow is a better tracker on the box, and its word reaches the phone through the row.

And a shift can be discarded while it is still developing. History offers the keys as soon as the shift has ended; the box reads the decision right before it banks, keeps nothing, drops what it uploaded, and says so.

And the crop gets what a detector wants from a dim bay: its exposure is stretched so the darkest and brightest two percent sit at the ends of the range, and a light unsharp mask firms the edges motion blur softened. A well-lit crop is left alone.

The ticks map to the film's own span. The box lays the film down one frame every 2 s of the shift (film_frames × film_step_s), so a moment's place is measured against that span from the first frame — not against the last kept moment, which made a watchman's late tick land early whenever the beat ended before the shift did. Older films (one frame per kept moment) still map first-kept to last-kept.

Kymani: "how about you just use a model that does this." Right. For following a person, everything hand-rolled comes out of the loop. The ring is driven by the model pair, detector plus pose; when they blink it holds where the body was last confirmed, takes the box's fix if one comes, and calls the body lost only after four seconds unseen. Follow me seeds nothing until the first confirmed body, which seeds the tracker at the body. The patch, motion and vest senses now vote only when following an object you touched.

The phone does the same now. A person detector loads beside the pose model, and a pose only counts when the detector sees a person under its torso: checked on every jump and every sweep, and re-checked every eight frames while steady, so a chair cannot hold the ring for more than a moment. Refusals are counted in the phone's report.

So a pose must be where the body should be. One farther than a third of the view from the prediction is a jump, and a jump is taken only when it holds the same spot for three frames running — a real body that moved fast stays, a hallucination flickers. A body must be taller than it is wide. The model's own presence bar goes from 0.35 to 0.6. The report now counts what was refused and samples the fix path, so the next run can be laid over the box's track of the same seconds; that overlay, not a feeling, decides whether the phone's eye stays the primary.

So the phone reports on itself. While following, every five seconds it stamps onto the job how many frames arrived and were stepped, the frames a second, whether the pose model loaded at all and what it costs, which sense held the fix on each frame, and how often the box had to step in. The strongest suspicion going in: the pose model was never loading over the camera's WiFi, and he has been watching the weak fallback tracker while the box held him 853 frames of 853. The eye now loads the moment the picture opens rather than at the first Follow, and the line says when it is loading or could not load.

And the box backs the phone up. Its fix is a few seconds behind but it never loses him. While following, the phone reads the box's newest fix every three seconds, and when its own eye has missed twice it goes there, looks there and opens its view. Between the two the ring should never wander off for good.

The library was already preloaded, so the library was never the wait. The wait was that Back destroyed the map and the next press rebuilt it: style JSON, then sprite and TileJSON, then the first tile, then the worker booting, then glyphs, then label layout — six round trips in a chain before one tile could paint.

Now the one map is built while the phone is idle, on the held job's ground, in a host div parked off-screen. Pressing Map moves that host into the frame and calls resize(); the tiles are already there. Back parks it again instead of removing it. Measured after: a warm first open under 0.2 s fast and under 0.4 s on 4G, a second open the same. Nothing about how the map behaves changed — marks, names, cards, Satellite, Recentre are the same code on the same map.

Now a vest that never moves is furniture. Each cell of the strip remembers how many frames running it has been hi-vis: a vest on a walking body is somewhere new every frame and stays young; a vest on the floor is old. At the touch, every hi-vis cell that is not on the touched body starts old. Only young cells count as the person, and the search is a body's reach rather than a quarter of the room. Proved on a strip with a pile of vests on the floor and a vest-wearer walking past it and then out of the picture: the pile never takes the fix.

So a shift's row at rest pictures nothing: the title line, where it stood, one bar per worker that ran with its moments as ticks, and the debrief. Press a bar and the moment opens in place under the bars — the film playing from that second (no bytes until then), or the frame itself when the shift has no film yet — with the worker's own words and a Close. The tile strip and the poster are gone.

"Further condense the rows for shifts… what would Apple do?" A shift's row is four things, top to bottom, nothing else: one title line (the lane — ULTRASHADOW, WATCHMAN — the clock, how long it stood, kept / moved / on site), where it stood, the film with one bar of moments per worker under it, and the debrief as the caption. The picture cell is gone from shifts (the film is the picture), the second line of numbers is gone, the hint is gone.

The vest is the tradesman's own beacon. Hi-vis is a saturated fluorescent colour that no wall or tool shares, and colour survives distance and dim light far better than the shape of a body: a person detector needs a hundred pixels, a vest blob is readable at five. One rule, in two places kept in step — fluorescent yellow-green or safety orange, bright and saturated; a dull olive fails. On the phone the vest is a sense between look and motion that carries a touched or confirmed vest-wearer at any speed, and Follow me takes the body with the most vest on it first; the line says the vest. On the box every tracked body carries how much of its torso is hi-vis, and the shift row says one in a vest. Proved on a synthetic walker at sixty-seven degrees a frame across the seam.

Keep or discard: on an ended shift in History, Keep marks the row so the sweep leaves its media alone; Discard asks once, in place, then removes every file the shift kept, every frame it filed, and the row says nothing was kept from it. The shift stays as a fact that happened.

Under it, one bar per worker that ran — WATCHMAN, TIMEKEEPER, PHOTOGRAPHER, WITNESS — with that worker's kept moments as ticks along the shift's clock and its count at the end. Press a bar and the film plays from the nearest moment, and the worker's own words for it print under the film: the box's why-kept note, then the eye's read. Every lane shows, so what a shift holds is read at a glance; the rows of frames and the tile strip are gone from any shift that has a film.

A shift with no film yet — still developing, or from before the film existed — falls back to a strip of its frames.

ByteTrack matches boxes by overlap between frames, which fails at ten frames a second when a body moves its own width per frame, and it does not know the strip wraps. It is replaced with an association built for this camera: match by distance measured in body heights with the wrap folded in, predict with velocity, confirm a body only after three frames running, hold a lost id for six seconds, and never let two tracks stack on one body. The strip is padded so a body standing on the seam is seen whole. A partial box is merged with its body by the fullest box, not the surest — a box on his legs had out-scored the box on all of him.

Proved on his recorded walk twice: as it was, and turned half round so the whole walk crosses the seam. One id, 501 frames of 503, no double bodies, either way.

The street is still written once per record (ai_notes.place, by the ledgered Photon call), but a row that only has numbers now asks for its words as it comes near the screen. The asks are batched — a quarter-second's worth of rows in one POST to /api/sites/place — and the server geocodes one SPOT once however many rows stand on it (the fix rounded to ~11 m), ten spots per call, the rest asked again a moment later. A burst of shots of one panel is one geocode, not thirty.

Why the phone could not: it sees a frame halved to 1328 wide, and at five metres a person is thirty-five pixels tall in it. Nothing reads that. The box gets the full 2656 by 1328 stream at thirty frames a second and has an RTX 3070 Ti. On the walk he recorded — grabbed from the relay's chunks, because the phone drops off ADB the moment the camera connects — a person detector plus a 17-joint pose model plus a multi-object tracker found him in 1005 of 1005 frames, far end of the bay and lights-off end included, one unbroken track. All open weights, Apache and MIT, no Ultralytics. 46 ms a frame on the GPU.

It is wired into the shift now. The worker starts a tracker servant at clock-in in its own environment, feeds it every chunk at ten frames a second from a background thread so the eye never waits, stamps who is in the newest frame on the row every few seconds, republishes every person's path while the shift runs, and writes the tracks into the record at clock-out with one ledger row. If the environment is missing or the servant dies, the shift goes on without tracks; it is a gift, never a gate. The stitch moved into its own module shared by the eye and the tracker, and its blend went from 106 ms to 11.

Checked, because he asked about Insta360's DeepTrack: the MediaSDK on the box has stitching, denoise and ColorPlus, and no tracking API. DeepTrack is in their app, not their SDK. Ours holds him.

Now a shift's row is its debrief, then ONE LINE (the lane, how long it stood, kept / moved / on site), who was here on one line, the film as a key that grows only when pressed, and every kept frame as one strip of small tiles — the frames that had something to say first, eight at rest, +N more in place. A pressed tile grows under the strip with its lane, clock, why-kept note and the eye's read.

Every record is now ONE ROW of the same table: a picture cell (or the kind word, so the rows line up), then the meta line — kind, clock, the job on Every job, where (the street once it is known, else whether it carried a fix) — then every word it holds, in full. No clamp, no ellipsis, no contact-sheet grid, no timeline.

A night finding prints its sentences with the frames that prove them, right in its row. A shift prints what the worker was, the counts, who was here, the film, the frames that had something to say as rows, and the steady beat as a strip. A call prints the writer, whether it answered, the tool, what went in, what came back, when and how long.

The only thing that moves: a picture grows to the row's own width in place (a still flat, a 360 on its sphere, a clip with controls) and shrinks again. A mark pressed on the Map, or Claude's door back, lands on that row in History, lit for a breath — never on a page.

A shift's row reads its job and its frames only once it is near the screen (an observer rooted on the page's own scroller — rooted on the viewport it never fired for anything below the first screen), so a record with thirty shifts does not fire sixty requests on open.

Only Vercel holds R2's keys, so the box now asks /api/scan/r2-sweep — a box-only door that opens on exactly two shapes, output/<job>/shots/ and output/<job>/film.mp4. Scan inputs, splats and builds cannot be named through it. The thumbnails stay, and each still's row is repointed at its thumb on whichever store it came from, so the record keeps its picture.

One R2 client now lives in lib/r2.ts; the upload-url and video routes stopped carrying their own copies.

Now the watchdog says so first. Field writes the fold that is open, the record you were reading and how far you had scrolled, and after the reload it opens the fold, walks back into the record once the ledger holds it, and puts the page where it was.

A plain open still starts closed. Only a deploy writes the marker, it lives in this tab alone, and it goes stale after three minutes.

Found on the way: after any reload the browser kept the old history depth on the page, so the first Back after a restored record did nothing. The app now stamps depth zero on boot.

The frame it kept says why. From across the shop he is about sixty pixels tall in the whole 360, ten degrees. The eye's re-find used a 90-degree view, which made him a 25-pixel smudge by the time the model saw it; one miss snapped the zoom wide and it never found him again. So: a proper virtual pan-tilt-zoom camera. It re-aims only when the body drifts out of the middle, zooms in by steps until the body fills half the view, zooms OUT one step per miss instead of snapping, and after three misses sweeps around the prediction at fifty degrees. A steady view is also what lets MediaPipe's own body tracking do its job; re-aiming every frame was throwing that away.

It has a memory of what he looks like: a colour signature of the torso, learned while it is sure, so a body it finds on a sweep can be told from someone else. Frames come ten a second now. The model is full, not heavy, because holding a walking body is about continuity, not joint precision — measured on his own phone over ADB: lite 27 ms, full 34, heavy 71 on the GPU. And the fix no longer re-renders the worker screen ten times a second.

Paired to the Razr over wireless ADB for the first time: the benchmarks, the install check, and a recorder that will turn his next walk into a dataset. Needs the 10fps APK.

A day is a page: its name large, then one quiet line saying what it holds (4 photos · 1 finding · 1 shift · 1 note) instead of a bare date.

Photos are one tight contact sheet with the clock stamped on each tile (and · 360 or · clip where that is what it is).

Words are a timeline: a thin line down the gutter, the clock and a small glyph per entry, one clean left edge. Notes, answers, papers, calls each wear their own mark.

A shift row wears a strip of its film and says what it kept — Shift · 41 frames · 2 moved — or On the clock / Developing while it is still working.

The night finding is a card in the read wash: the record spoke, and it looks different from what you filed. It says how many frames it cites.

While the record loads, faint placeholder lines hold the page instead of a Reading… word over nothing.

The person eye is a pose tracker now. MediaPipe's pose landmarker finds one body's 33 joints and, in video mode, follows that body from frame to frame on its own, re-detecting only when it loses it. It reads a body that is turned, half hidden or blurred where a box detector's confidence simply fell under the bar and the mark bounced. One pose per crop, and the crop is centred on you, so the body it picks is you. The follower fixes on the torso; the outline is your own skeleton drawn on the sphere.

Free and keyless: Apache-licensed, public model files, no account, and nothing leaves the phone. The first load pulls the runtime and model from their CDNs; the service worker keeps them after that.

One trap on the way: the skeleton drew off the man because the sprite was re-centred on the torso each frame while its drawing was laid out against the body's box. The sprite keeps the box's own offset from the fix now. Proved on the shop frame with the real model: a touch on Kymani locks as a person at his torso, a touch on the wall does not, Follow me finds him, and the skeleton sits on his body.

The field says Search by address or date, and a date really does find the day — "sep 2", "9/2", "2026-09-02", "tuesday" — matched as a whole phrase, never word by word, or "2" would match every day. The recent row is pinned to the page's width and scrolls inside itself; the page itself can never scroll sideways again, whatever a child does. And the search — its words, its place, its scope, its kind — lives for the session now, not for the view: open a record, come back, and you are still standing in the same archive. It clears when the app is next opened fresh.

The bounce was policy, not speed. At distance or in blur the detector's score dips under the bar for a single frame; the box was dropped that instant and the ring shown at the tracker's own guess, then the next frame found the person again. Now a miss keeps the box, carried by motion and look, for six misses before the ring shows. A person already near the fix needs a lower score than one found by looking around, and looking around starts later.

And the eye zooms. Its 90-degree view made someone far down the bay a twenty-pixel smudge no detector reads. The view now narrows until the person fills about half of it, down to thirty degrees, and opens back up to look around. That is what 'at all distances' needed.

The line under the eye now prints how long a detection takes on this phone and whether it is running every frame — so the next question about speed is answered by the phone, not guessed at.

A tracker that knows the patch you touched and whatever moves does not know what a human is, so a wall with the right texture or a swinging cord could win. Now there is a sense that does. MediaPipe's person detector runs on the phone itself, on a square 90-degree view the sphere renders around where the thing should be — a person near the horizon of the 360 strip is a smear, but in a 90-degree view they look like a person. Nothing leaves the phone; there is no API and no vendor, so it is not a ledger call.

A detected person outranks look and motion. The orange ring becomes a box drawn around them on the sphere, the line says a person, and if nobody has been near the fix for a few frames the eye looks around a quarter turn at a time until it finds them again. A Follow me key under the eye locks onto the biggest person in view with no touch at all.

Proved with the real detector on a real shift frame from the shop: a touch on Kymani at the desk locks as a person at his position, a touch on the poster wall stays a touch, and Follow me finds him. The first load pulls the runtime and the model from their CDNs; the service worker keeps them after that. A phone that cannot run it falls back to touch and motion.

Same 5fps APK as the last entry; nothing native changed.

One faint row under the field while it is empty: the last six things looked for — words or a place — newest first, tap to look again, a small clear at the end. A search is remembered once it has rested a moment and found something, so typos never join the row. Kept on the device.

Two rows now. The search field says what it searches, Search Redland @ Crabbs or Search every job, with Map beside it. Under it, one toggle for Every job, Filter, whatever filter is on, and Ask Claude only once you have typed a question for it to carry. The count is gone from that row; the History row's own summary already says it.

Every record is the same quiet row: the time, the words, and a small grey kind word. The job name appears only when you are looking at every job. Day headers read Thu, Sep 3 instead of shouting. The only colour left is the red on a worker's shift. The contact sheet for photos, the wall of tasks, the filters as a second search, all untouched.

Two things. The frame cadence really was slow: the phone's decoder emitted a frame every 500 ms and the monitor polled every 500 ms, so a frame could wait nearly a beat to reach the tracker. Both are 200 ms now, five a second end to end. That half needs the new APK.

And the tracker trusted only appearance. A fast mover blurs and drags new background into the patch, the score falls, and after two misses it gave up. It has two senses now. LOOK is what it had, but searched around where the thing is predicted to be, last fix plus velocity. MOTION is new: the camera is parked, so the difference between this frame and the last lights up whatever moves, and the moving mass nearest the prediction is where the thing went, however fast and however blurred. A mover lights two blobs, where it is and the spot it just left, so the spot just left is passed over. When neither sense answers the fix holds for three seconds before it says Lost; a person who stops behind a chair has not gone.

Every trap found on the way is pinned: the vacated spot, a flat black band learned as the thing's new look, a wall learned where the thing used to be. A learned look must still resemble what was touched. Proved in Node on a real X5 frame with a smeared walker at fifty degrees a frame, across the seam, and in the browser with a thing that jumps and then vanishes.

Type a road or a place and the roads and places that match ride under the field. Pick one and the record is cut to what was taken within a mile of it, with a chip that says so and clears in one press. Near me does the same from where the phone stands. The words still search the notes, and a record's own street counts as words once it is known.

A record's street is found once — the fix reverse-geocoded through Photon, ledgered, written onto the row as place — and read forever after: WHERE among the facts says "8611 Grovemont Cir, Gaithersburg", never coordinates. The Where tab, the ground map under a record and Stand Where This Was Taken are deleted, and the three specs that guarded them retired. The Map behind History is still one press away for anyone who wants the ground.

The holding law always said arriving on a job's ground holds it; the new front never did it. Now standing within a stone's throw of a job holds that job. A job you pick on purpose, by Swap or Hold, stays held while you stand there, and the ground takes over again only once you have left it by a mile. Near a job but not on it, the line still says near and offers Hold.

Three things were wrong, and the test found all of them. The view was 80 degrees tall, which at 2:1 is 118 across, so the edges smeared; it is 65 now. The sphere was MIRRORED: three.js is right-handed, a camera looking down +z has its right hand at world minus x, and I sampled the strip at plus x for plus x — his screenshot hung the Maryland flag on the wrong side of the desk. Every crossing between the world and the strip now goes through one pair of functions, and the stitch is proved on a real raw X5 frame, not a frame I synthesised from my own idea of the lens.

And the tracker was on the wrong machine. The box sees two frames per five-second chunk and its fix reached the phone five to ten seconds later, while the window refreshes twice a second. That can never look like following. The tracker now runs on the phone, on every frame the sphere is handed: each frame is also drawn off-screen as a small strip, read back, and matched in about twenty milliseconds. The box's tracker is deleted; the route only names the thing.

One more trap on the way: the adaptive patch. A patch that refreshes on a borderline match is half wall, and a patch that is half wall follows the wall after the person walks away — which is precisely 'the dot didn't stay on me'. The patch you touched is the authority now; the latest patch only refreshes when the touched one scores high. Proved in Node on the real frame across the seam and through a loss, and in the browser with a thing that moves and then vanishes.

No new APK needed for this — the native side is unchanged.

Connect now puts the camera on standby: its stream is open and the phone decodes it for the live eye — you see the picture, aim, wait — and nothing is written: no chunks, no uploads, no pings. Start adopts that same running stream, so it is a switch, not a second connection, and every chunk now carries the stream's header so a shift that begins mid-stream decodes from its first frame. Leave without starting and the stream closes.

The fold keeps the worker mounted when you fold it away, on standby or on the clock, so folding closed never drops the camera or re-runs connect on the way back. One shape still: the picture, one line, one key — Connect, then Start, then End.

The top-right Ask the record is deleted, and with it the app's own ask screen and the stream reader nothing else used. Three ways to ask became one: the record is asked through the person's own Claude, from History and from the worker space. The header is the wordmark and refresh. The app never becomes the AI.

The first Summon failed on every shift on the 5th: the connect timed out at 10 seconds while Android was still joining the camera's WiFi, which takes up to 30. The clock has two hands now: the whole attempt may take 45 seconds, and the camera's open gets a fresh 12 from the moment its WiFi is up. New APK.

Every row, proof frame and shift the connector hands Claude now carries a link back into the app on that exact record: /?record=<captureId> opens the capture, /?shift=<jobId> the shift. Ask in Claude, tap the link, stand on the frame in Tradesman. Two taps. The ask route's proof frames carry their capture id for it, and the app opens the record on arrival once its record has loaded, then strips the param so a reload is home.

The other half is the street under your feet. Off every job, the line now reads the distance and the address you are standing at, from the same reverse geocode the new-job flow uses, asked once per hundred and fifty metres of movement and never more than twice a minute. In Frederick it would have read 33.0 mi · 2317 Humphreys Peak Ct, Frederick, and there would have been no question what the app thought.

Three things changed. Here now means within a stone's throw, a hundred and fifty metres; the mile stays what it was, the ground where a capture files, but inside the mile and beyond that throw the line prints the real distance, and another job's ground reads near it until you are actually at it. The job list says what every job holds, or nothing filed yet, when it was last worked, and its street. And History's summary on the job you hold is that job's own count, Nothing filed yet when so, with the same words on its wall.

So the screen he had would now have read Parklawn Terrace · 0.6 mi, and the list would have said nothing filed yet under it.

A record is one sheet the height of the glass now. The top is a lens: the photo, the 360 on its sphere or the clip, and one press flips the same area to where it happened on real ground. Under the lens the note, clamped to a few lines and pressed open when you want all of it, then every fact that exists about the record in one grid: when, which job, where and whether that is its own fix, the kind and file, whose hand, and the keys.

A shift is the same shape: who stood where and how long, the three numbers, what happened clamped, then one lens with four faces: the film, what it kept, the day in order, where. Whatever cannot fit a face scrolls inside the lens, never the page. A test opens both and checks the page itself does not scroll.

Search got sharper too: every word you type must match, in any order, and the kind's own word counts, so photo strut, note claude and shift redland all find what you mean.

The rest of what he asked for was already true after the other session's work last night: pick the 360 camera or this phone and the shift connects and starts on its own, there is no length to choose, and End is the only other key. The phone's eye is its own live stream; the 360 camera's eye is a frame every few seconds until the live picture lands.

What they tripped on, and what changed. A record that could not be read printed Nothing filed yet, which is a lie; it now says the record could not be read and offers Try again, and the row's summary says Could not read. A search that missed on the job you hold gave up; it now says it missed on that job and offers Search every job. Eleven keys were under the glove size: the filter pills, Filter, Ask Claude, Add a task, the Task chip and the day key on the note card. All of them are 44 pixels or taller now, and a test measures every key on the front so one cannot shrink back. The photo tiles had no name for a screen reader; they carry their note now. The Add row listed all eight tools and trailed off in an ellipsis; it says its front four and more.

What held up: back from a record or the map lands you exactly where you were with History still open, summoning and changing your mind is two presses, swapping jobs is two presses, and nothing on any screen sits under the phone's own buttons.

The view is a stack now. Shift → frame → its map: each one pushes, and Back — ours at the top-left or Android's — pops one step. The page you return to is where you left it, scroll and all, even while its frames are still landing. Each push is one browser history entry carrying its depth, so the phone's button and the stack can never disagree.

And the job row above the folds is centred like a fold header, with the name a step above a fold title and the words at the fold's size — it sat on the baseline before, and looked off.

Each job on the Swap board now has ⋯ with two doors, in place. Merge into… picks the job that keeps it all: every capture, every walk and shift, every ledger row is re-pointed, nothing copied, nothing dropped, ids and clocks and media untouched, and the empty shell goes away. Delete is for a job that holds nothing. A job that holds anything says so and offers the merge instead — the old delete route removed the job and stranded everything filed under it where nothing could reach it; it refuses now. Both doors say exactly what will happen and ask once.

The live eye added yesterday decoded the X5's stream on the phone twice a second, but cut the front lens out of the dual-fisheye frame before it reached the screen — one marble. The box's own eye was a proper stitched 360, painted flat. Neither was a place you could look around.

Now the phone hands over the whole dual-fisheye frame (halved, about 70 KB, so the bridge does not notice) and the monitor draws it on the inside of a sphere with a fragment shader that uses the box's exact lens model — equidistant, 190 degrees, a six-degree feather across the seam. Proved against a real shift frame: the GPU stitch and the box's stitch differ by about three levels out of 255, and the seam through the middle of the turned view is invisible. tests/eye-stitch.spec.ts measures it on every run. Drag to look; the frame swaps in place so where you were looking stays put. When there is no phone window (an older APK, or watching from another device) the box's equirect goes on the same sphere.

Touch a thing on the sphere and the worker follows it. The tap is a direction in the equirect's own coordinates. One Haiku read names it ("the man in the black shirt", "the red tool cart"), ledgered like every model call. The box does the following, because the box has every relay frame: normalised cross-correlation against two templates — the one you touched, which never changes, and the latest good match — searching near the last fix, then the whole strip if it slips, rolling the strip so the seam is never in the way. It stamps stats.follow; the sphere glides to it and a ring rides the thing. The line under the eye says Following, Lost — touch it again, or Stop. Tested on the shop's own shift frames across the seam, through a loss and a re-find.

Two writers, three keys, one lock: the phone owns follow_req and follow_name, the box owns follow, and every write goes through the merge RPC the box already used, so a tap and a tracker tick cannot erase each other.

Needs the new APK for the live window (the box's eye works on the old one). The phone rig stays a flat video — it is not a 360 camera.

Standing on another job's ground, the line reads at that job, and its one key says Hold: one press and you hold it. Anywhere else it says here, or how far, and Swap. Same line, same one control, the same mile-around-the-work ruler the rest of the app uses.

A second state, somewhere new with a New job key, was built and cut within the hour: the harness showed it would nag New job at the shop every single day. New job stays in the Swap list, where you go on purpose.

The Worker fold at rest is now the same space the worker works in: the picture (the last shift's eye, dimmed), one line, one key that says Start the worker. Pressing it connects the camera and starts the timelapse in one go — no rig picker, no Start after connecting, no confirm. The phone rig is a line of words under the key. When the shift ends the fold hands itself back at once; History has the report.

The Add fold shows all eight tools the moment it opens. The More key is gone.

Keep is deleted: the chip on the Note card, the Keeps block on the wall, the flag. It said the job should never forget a note; the night clerk already keeps a standing memory page for every job, so the flag did the same work twice and every person who saw it had to learn what it meant. Old kept notes stay in History as ordinary notes.

Tasks stay, and they have one name now. The app had called the same thing Task on the Note card, Lines in History and Owed on the wall. It is Task everywhere, including the two connector tools Claude uses, because that is the word you say.

History now opens on the job you hold. At the top of it, before the days, the wall: what the job is owed, its open lines, tickable, with a way to add one, and what it keeps, the lessons it never forgets. Nothing to filter for. Every job is one press away, the same two pills the Map uses, and on Every job the Filter's Job section comes back.

And the Note card now says Line instead of Task, because that is the word you find it under.

The Worker row shows exactly one thing at a time now: the summon key, or the two rig keys, or the live shift with its eye and its controls, or the shift that is developing. The last-shift card is gone; every shift is in History. The offer to allow notifications is one quiet line under the live shift instead of a card of its own.

The four trades are gone from the front. One worker: TIMELAPSE. The box keeps every 2-second frame into the FILM — stitched small, one mp4 per shift at 12 frames a second, about 5 MB an hour — and one frame a minute into the RECORD as a capture row with a 14 KB thumbnail. Motion is a tag on a frame now, never a worker: the best frame of anything that moved joins the record marked "moved", searchable. The four old lanes stay in the table only so old rows keep their words.

Cost, by construction. The record still leaves the box at 1024 wide, about 80 KB, while the full-size master stays on the box's own disk, free, with 1.6 TB to spare. The eye reads only frames that changed against the last one read (a 64-bit difference hash), moved frames first, one anchor every ten minutes, forty reads a shift at most — the index pool never sees the rest. Shift media goes to R2 the moment its bucket has a public address (one toggle in Cloudflare; the box has the switch), and until then a sweep sheds full-size stills after 14 days and films after 30, pointing each row at its thumbnail so nothing goes blank. An 8-hour day is about 45 MB of record and 40 MB of film; a month stays inside R2's free 10 GB.

Found on the way: the R2 presign route minted upload links for anyone who asked. It now takes the box's key or a signed-in owner, and lets the box name a shift's files by job so the record's URLs are stable.

Now it is one shape in every state: the picture (the camera's eye when on the clock, the state's word when not), one line, one button. Link the camera, Start, End, Done — always in the same place. While it works: the ask, the door to Claude, and the three tools sit under the line. The kept-frames grid and the in-fold report are gone; History holds the reel, the words, the numbers and the film, and the space says so when a shift ends.

Claude can now write two things into your record through the connector, and only two: a note on a day, and a line a job is owed. They are the same rows you would write from Add, and History prints via Claude beside them so you always know whose hand. It cannot touch the camera, the worker, or delete anything; the contract test names the two writes and fails on a third.

And Claude has a row on the page, the mirror of Worker. Worker is the eye's presence: who is on the pole, since when. Claude is the mind's: connected or not, how many times it read the record today, what it did last, in words, off the ledger, and the door to ask it about the job you hold. If it has never connected, the row is the connect card. There is no chat field anywhere in it. The chat is Claude's; this is the record saying who has been reading it.

The same component, mounted by the engine room as before, rendered in place instead of in the overlay slot. The full-screen form survives only as a switch the specs' stand-in can flip.

Reading the phone's log during a shift is impossible — the phone leaves the shop network when it joins the camera's WiFi, and wireless debugging rotates its port and turns itself off on the way back. Kymani, after the third pairing code of the night: "I can't do this back and forth." So the phone now reports the live eye's state — decoder size, last frame clock, last error — on the ping it already sends every few seconds, and it lands on the job as stats.live_eye. Whether the eye is up is a fact of the record now, not of the phone.

Also tonight: the live eye's first build went through an ImageReader, and this Snapdragon's decoder handed it a buffer with no CPU mapping — a JNI abort in the live-eye thread that took the whole app down two seconds into a shift. The stream never arrived; the box waited. The eye now reads the decoder's own output image, which is CPU-backed by design. The crashed shift was marked failed by hand with the reason on its row.

Ask Claude opens your own Claude with the question written, but a Claude without the connector installed cannot see the record. The ledger already knows whether yours has ever read it, because every connector call is a row under the door named claude. So on a phone whose Claude has never read the record, the first press opens a small card in place: the one address, a Copy key, three steps, and an Open Claude anyway for anyone who knows better. Once the ledger has seen your Claude, the door is just a link again.

No chat of ours, no new table, no flag to keep in step. The record is the evidence.

The relay already receives the X5's raw H.264 on the phone. LiveEye.java tees those same packets into the phone's hardware decoder, reads the stream's size off its own SPS (the camera ignores what it is asked and says so only there), and twice a second compresses the front lens of the newest frame to a small JPEG. The plugin hands it to the WebView on request; the monitor polls it while a shift runs and shows it with a LIVE pill. Nothing is uploaded, the chunks that go to the box are untouched, and if the decoder cannot start the monitor keeps the old eye. Ledger: a poll, not a call.

Built as a debug APK on the box and handed over by link — the phone had dropped off wireless ADB. Untested on the X5 until Kymani runs the next shift on it.

This closes the pattern that started with Note and Part: anything that is not a camera is written in place. A camera keeps the whole glass.

I also tried filtering the skipped rows out in the database. It made the query three times slower, because the filter has to open every JSON blob to read it, so that idea is written down as rejected.

Part follows Note into the page. Press Part in Add and the grid becomes the finder: name the part, Find, and the doors open under it, the big boxes' search pages with the exact words pre-typed and the supply counters near you with a number to call. Or shoot the part hands it to the camera, which is the one thing that still takes the whole glass.

Three things were wrong at real size. The list was 56 identical WITNESS rows — an hour would be 180. Every thumbnail was the full 2656-pixel 360 still, about 22 MB to draw a list. And the visit line said "21:38" beside a debrief that said "9:38 PM".

Now: the box writes a 360-pixel thumbnail beside every kept frame and the page uses it, falling back to the full frame for older shifts. The kept list is rows only for frames with something to say — it moved, someone was here, the debrief cited it, the eye read it — and a contact sheet for the steady beat, each tile its lane and clock. The visit clock is the one people say. And a shift's row in History carries the debrief's first sentence instead of the words WORKER SHIFT.

A sixth tool, tradesman_look: look through the worker's camera on a job right now. It returns what the eye sees this second and the newest kept frames as images, each with its lane and about when — read off the reel the box already publishes as picks develop. No model call on our side. Claude is the eyes, and describes what is in the pictures itself. After a shift it returns the last shift's frames, so "what did it see" always has a picture.

The box fired the first shoulder tap and the ledger said sent: 0. The push_subscriptions table was empty — nobody had ever been subscribed. The only ask lived on the worker's clock-in screen, which runs on the phone, whose WebView has no Push API. So every tap since August 27 went into the void. The Worker fold now offers one row while a shift runs — "Tap me here when something moves" — in any browser that can receive one, and re-arms a browser already allowed so the subscription is on file. The APK still cannot be tapped; that is Android's rule, not ours.

Also: the connector's job_id now accepts the job's name as well as its id — Claude types the name it just read — and says plainly when a job does not exist instead of silently answering for every job.

Press Note in Add and the grid becomes the note: one field that grows as you type, the day, Task and Keep, Cancel and Save under it. Nothing slides over the page. The job line and the row you pressed stay in view, the phone's keyboard shrinks the page and brings the field up, and Save folds the card back into the grid with the note already in History. Cameras keep the whole glass; everything else will follow this pattern, Part next.

The keys: no outlines anywhere. A key is a soft grey slab. The one key that matters on a page, Summon, Save, is ink. The burnt accent now means only two things: a link, and something live.

One: "when I close out the worker its shift doesn't really go anywhere." It did not — but the front hid a shift the moment you ended it, and History labelled it WORKER ON THE CLOCK until the box turned it done. Between End and done a shift is DEVELOPING: the box is filing what it kept. The box now stamps the turn (shift_ended_at), the phone's End already stamps live_final_count, and all three surfaces say DEVELOPING — the Worker fold keeps a card for it, History labels the row, the shift page explains what is happening.

Two, from the pairing: Claude said "I asked for the photos back and got none." True, and never once had it worked for a shift. The box uploads every shift frame as application/octet-stream, and the connector asked the content-type header before trusting an image, so every 360 still was refused. The connector now sniffs the bytes, and the box types its uploads by extension. Also true, Claude's own flag: the day tool matched a UTC day slice beside the local day, so Sep 4's 11:35 PM frames answered as Sep 5 while search dated them Sep 4. The day tool reads the owner's local day only now.

And the question the connector could not answer during a live shift — "what did the worker see" — has an answer: a shift ON THE CLOCK now comes with what its eye sees right now as an image, and what it has watched and kept so far in words; a DEVELOPING shift says its frames become captures when it turns done. Verified against the record: the search that returned no images before this returns them after.

The Add fold is your hand, through the phone. The shift monitor is the worker's hand, through its eye, and its keys are the very same keys with a red dot in the corner saying whose eye the frame comes from. Keep this became Photo, Read panel became Panel. Add a frame tool to the belt and the worker can use it too, with nothing to configure.

Worker stays presence, Add stays verbs, and History is the shared book: the worker's rows are one filter away, By the worker. The third piece, choosing between your viewfinder and the worker's eye when both are live, waits for the first shift where both hands are on site.

The shift page drew its reel from storage filenames, so every kept frame was a nameless square. Each of those frames is a row carrying its lane, its clock, the sentence the box wrote for why it kept it, and — after the overnight index — what the eye read in it. A new owner-only door, /api/shift/frames, returns those rows; the page lists them as rows, wearing WATCHMAN / WITNESS / PHOTOGRAPHER / TIMEKEEPER and the words. The frames the debrief picked as proof sit right under the debrief's sentences. One line at the top says, per worker kind, what the camera did: "The X5 stood still for 2 min with all four workers on it: the photographer kept the sharpest shot of each minute, the watchman kept a frame each time something moved…". A kept frame opens as a record of its own, on its sphere, with its WHERE.

The night finding's [C#] markers are now numbered marks, and the frame each one names sits under the sentence that cites it, with its note and time — the bonded pair applied to a finding. The clerk already files marks and the brief route already hydrates the frames; the phone had been stripping both before storing. The code reader's findings follow with their article and their frames. History's list row reads clean, and the finding wears the clerk's real filing time instead of a fake end-of-day stamp.

The job you hold is the context of everything under it, so it now holds at the very top of the screen while you scroll, with Swap one press away, and the row headers stack under it: Worker, Add, History, then the search line.

Decided: one at a time. The page is one thing you are doing, and a closed row is a door, not a loss. Opening a row closes the other.

Every row header you scroll past now stacks at the top in page order, Worker, then Add, then History, so however deep you are in the record the three doors are one press away. In History the search line holds right under the stack.

To make the headers hold against the page itself rather than their own section, the two halves of the page no longer wrap themselves in a box; they lay their rows straight onto the page.

The app now always opens as the blank page: the job line and three closed rows. Nothing is remembered between opens.

Open a row and scroll into it, and its header, the word and its summary, holds at the top of the screen while the content scrolls under it. One press there closes it from wherever you are. When that row ends the next row's header takes its place. In History the search line holds right under the header, so the title, the count, the search, the map, Filter and Ask Claude are all in reach from any day in the record.

This replaced the separate title line the search block used to grow when it held; the row's own header does that job now, with less code.

A finished shift's row in History read "W 5 · W 2 · T 0 · P 2" — lane initials, two of them the same letter, from Kymani's own field notes as unreadable on a pole. It now says what each lane did in the roster's words: "5 kept · 2 moved · 2 visits · 40 min on site". A lane that did nothing stays silent, except kept.

Confirmed from the ledger: both night clerks ran on schedule for the first time this morning (code read 04:51 UTC, night read 05:00 UTC). The code reader filed nothing — silence is the normal night.

Every dot used to be a small piece of the page that the map dragged around on every frame; on Every job that was 493 of them and the pan stuttered. The marks and the jobs are data the graphics chip draws now, in one pass, and the map's own collision engine decides which names fit at this zoom.

A job is a dark pin wearing its name. A record is a small dot; tap it and a card says what it is, when, and which job, with an Open key into the record. Satellite and Recentre are unchanged.

Tiles you have seen now stay on the phone between opens, so a job you looked at yesterday draws from the phone today and pans before the radio answers. The map's code warms while the phone is idle so Map opens at once. If the map cannot load, it says so and offers Try again instead of a grey box.

The frame fills what is left of the screen under the head and the scope row, never less than a phone's worth, and it is still a page, not a window over one.

It was a photograph. Every drag and every zoom step asked our server for a new Google still, which asked Google, which sent back a new picture: two round trips and a blink per gesture. No cache makes a still fluid; a still is the wrong object.

The map is now MapLibre drawing OpenFreeMap's vector tiles on the phone's own graphics chip. Pinch, drag and zoom are continuous, tiles stream in behind your finger and stay cached, labels stay sharp at every zoom. Satellite is Esri imagery laid under the road labels when you ask for it. No key, no quota, no server in the way, and the attribution prints in full.

Same marks, same blue dot for you, same Recentre. The Google still survives only for the shared live link, which draws a small day map for someone without the app.

Then the real find of the night. His shift page said No debrief was written, and no shoulder tap ever arrived. The box's own log had the answer: every tap and every debrief request came back 404. The box signs its calls with its Supabase secret key, and Supabase now issues that key in two shapes: the old long JWT, which Vercel holds, and the new short sb_secret key, which the box holds. Both open the database, so the box never noticed; but the two routes compared the string to the JWT alone.

One shared check now accepts either shape, Vercel holds the box's key too, and the two missing debriefs were written by hand tonight. The lesson for the file: when a worker feature goes quiet, read worker.log and the ledger before reading code.

Once the search line is holding at the top it grows a title line, History on the left and the record's count on the right, and the Filter and Ask Claude row rides in the block with it. Back at the top the title line goes away because the fold header already says it. A one-pixel sentinel above the block tells us when it is holding.

Send the day is out of the app: the button on today's header, the name sheet, the packaging code and the prop that carried it. About a hundred and thirty lines gone.

Why ending felt slow, measured on the two shifts tonight: pressing End waits up to ten seconds for the relay to drain its last chunks, then the box takes up to sixteen seconds to close the shift and mark it done, and the front only re-read the record every ten seconds. So the block could say on the clock for half a minute after your thumb left the button. Now a shift you end on this phone is treated as ended at once, the record is re-read the same instant, and the toast says plainly that the worker is developing and where the result lands.

So the way back is a link. Ask Claude sits beside Filter in History and under the worker's own answer on the shift monitor. It opens the user's own Claude with the question already written and the connector named for that job; their Claude already holds the record. The search words become the question. No chat of ours, no key of ours, and every press writes a ledger row so the door lives or dies on evidence.

The ledger also showed a phone-camera shift opening the camera four times in one second. The shift only counts as live once the eye is open, some ten seconds of GPS and permission prompts after the press, so a second press in that window started a second shift. The guard now sets from the first instruction.

The ledger told the story before the code did. His 03:35 shift shows the camera connect, the relay start and stop, the box's relay row and the indexer, and not one model call. The Ask button summoned the old on-glass keyboard sheet, and this screen never mounted that sheet. A press did nothing, silently.

Now the question is a plain input on the monitor with the phone's own keyboard, an Ask key beside it, and the answer printed under it. The test types a question, presses Ask and reads the answer back, so this cannot go quiet again.

Also seen in the ledger and not yet fixed: a phone-camera shift opened the camera four times in one instant. Same class of bug as the double recogniser; it gets a guard next.

The page is now the job line and four closed rows: Worker, Add, What the night found, History. Each row is one line with a word, a summary and a chevron. Press it and it opens in place on the page, nothing floats, and the phone remembers which rows you left open.

The load time, measured on the real record: the record request moves about two megabytes of capture notes for 730 rows and takes over a second on the database alone, before sign-in checks, the function's cold start and the phone's radio. On top of that the app asked for open lines once per job, sixteen requests at boot. And nothing was drawn until all of it landed.

Two fixes. Every answer (the record, the lines, the night finding) is kept on the device and shown the instant the app opens; the live answer replaces it when it arrives. And the open lines come back in one request for every job instead of sixteen.

The 2 MB itself is still moved on every open. Shrinking that is the next step if the phone still feels slow on a warm open.

Pressing Summon now unfolds the worker block in place into two keys, 360 camera and This phone, with a small Not now under them. Nothing floats over the page. The key you press goes straight to that rig: the phone key opens on this phone's camera with no Insta360 search and no fifteen-second wait; the 360 key looks for the camera at once.

Both rigs stay. The 360 camera is the first key and the strong one because it is the product; the phone is the rig you always have on you. The phone key is not drawn on a device that cannot open its camera.

The test presses Summon, checks that no dialog exists and that the keys sit inside the page, folds it back with Not now, then fires each rig and checks only that rig fired.

That is what it does now. The line rides up with the page, meets the head, and holds on a white ground while the record scrolls under it. Search and the map are one reach away from any day in the record without scrolling back up.

One detail worth writing down: a sticky row measures its offset from the scroller's content edge, and the page has a 14 px top pad, so the row stopped 14 px short and clipped. The pad is one shared constant now and the row pulls up by exactly it.

After the phone sits a while its session token refreshes, and the very first request lands before the refresh finishes. The server honestly says "no session", and the front honestly believed it and cleared the list. The jobs list had the same hole and was patched yesterday; the record list is patched now.

Rule: a 401 or a signed-out answer on a poll is never allowed to erase what is on screen. Both polls keep what they have and ask again in three seconds. If you ever see an empty record again, it is a real outage, not this.

The deploy of this fix itself failed once: the devlog entry was written with notes as one string instead of a list, and the pre-build check only proved the file parsed. It now checks every entry's shape as well.

The camera sheets now use their phone rendering — a real shutter, a real record button — lifted clear of the nav bar. The note is one line that grows as you type, today by default, two chips (Task, Keep) and Save. The part finder is one line and a Find. Fewer words everywhere; the phone's own keyboard everywhere.

The canvases stay published for the record of what was considered. The direction is not a screen. It is the pole, the record, and Claude.

The connector's proof frames are resized on the server before they go to Claude: a 360 still off the box is two or three megabytes, and four of them in one reply would swamp it. Now each is 1024 pixels wide at a tenth of the bytes — still the frame as evidence.

The shift row is called WORKER SHIFT now, not ULTRASHADOW. The word left with the game.

One line under the doors says what the app is: A camera you leave on the job. It keeps the day. Ask Claude. Kymani: 'the UI and UX should be explicitly clear about our goal and mission.' One line, not a feature list.

Both are the same white page as the rest of the app now. The worker's screen is one rendering instead of two (the LCD one and a cream modal from the card era), with no ceremony in front of the work: camera found, how long, Set it down. While it runs: the clock, the eye, what it has kept, Ask it what it sees, Keep this / Read panel / Code check, End the shift. When it ends: what happened in the worker's own words, then Kept / Moved / On site, who came, the film, Done.

The landing says the mission in three lines before it asks for anything: A camera you leave on the job. It keeps the day. Ask Claude. The skin art and its geometry file went with the last screen that drew them. The /get page now points at the permanent APK link the box uploads to.

This is the point of the feature. The failure was visible the moment it started, with the tool, the time, the exit code and the job it was for — and the fix is one line in two files.

Five tools, all read-only and marked so, so Claude runs them without asking permission each time: list the jobs, search the record, ask it (the frames that prove the answer come back as pictures inside Claude), read a day, and see the open lines. A token never sees past its owner's jobs, and there is no tool that writes. Every call lands in the ledger under its own door, 'claude', like any other caller.

The sign-in is OAuth with PKCE, the way Anthropic's connector docs specify, and it keeps no table: a client id is its own redirect addresses, signed; a code carries the user and the challenge; a token carries the user. Nothing to migrate, nothing that can leak from a database. One consent page, white, one ALLOW.

It installs today as a custom connector on any Claude plan, from the app's own address. The directory listing comes later; tradesman.ai will point here when it is set up. A contract test does what claude.ai does, in order: gets refused with the discovery pointer, registers, trades a code for a token, and calls a tool.

What the inventory found that nobody could see: the night clerk and the code reader had NEVER been scheduled. Their two cron lines lived only as a comment in a source file, and the record held exactly one night finding and one code finding in 734 captures, both run by hand. Twenty-one routes had no caller anywhere, three of them still holding live model calls. Four native plugins from the voice era were compiling into the APK with zero callers. The phone SCAN lane had no door on the device that could run it since August 14th.

Subtracted before adding: all of it is deleted, native side included — 88 files, the two dead lanes inside worker.py, the Bluetooth permissions, the LiteRT and Bluetooth packages, the Ghost eval scripts, the RunPod directory. Nothing archived, nothing commented out.

Added: the ledger. One table, tool_calls, with one row per external call — which tool, from which door, for which job, one line in, one line out, how long, ok or the error. Three writers, because the calls happen in three places: the phone wraps the Insta360 and ARCore plugins once at the door and owns the only getUserMedia; Vercel wraps every Anthropic, Google, Overpass, Photon and push call; the box records every stitch, solver and model read, and one row per shift rather than one per five-second chunk. A test reads the tree and fails on any call that bypasses it, and on any cron route missing from vercel.json — the check that would have caught the clerks a month ago.

Observability is a feature: HISTORY's Filter has a CALLS kind. Turn it on and the day shows what was called, when, what came back, and what failed; each call opens as its own page. Calls are never mixed into the record, which is what was captured, not what was computed.

CLAUDE.md corrected in the same commit — the Ghost line, the ArScan line, the operator card, the Watchtower, the cron claims — and the stale text deleted rather than stacked.

Correction, same evening: the table first said the daily-report cron had produced zero drafts. It has produced one every evening — thirteen so far. The count read the wrong JSON path. The clerks were never scheduled; the daily draft always was.

The first door is SUMMON now, in his word, and its one fat button says SUMMON THE WORKER. Under it, the ways to add to the day are the four he named plus the phone's gallery — Note, Photo, Clip, Upload — and the trade tools that also write a row (Measure, 360 walk, Panel, Part) sit behind one MORE TOOLS fold instead of doubling the page. Same rule as the History filter: a control appears when you turn it on.

Every record now opens in its spatial environment, not only the ones the phone stamped. A record with its own fix stands at that fix. One filed without a fix — a note typed at the truck, a gallery photo with its GPS scrubbed — still happened on its job, so it stands at the job's address, and the caption under the ground says exactly that rather than pretending it was placed. Both get Google's roads pinned and STAND WHERE THIS WAS TAKEN, the 3D ground, at the same point.

A record also opens as itself: a clip plays in place, a 360 still goes onto its sphere, a flat frame lies flat. Words stay full width. The two tests that guarded the old behaviour were rewritten: one proves an unplaced record is still placed and says so, one proves a placed frame's pin is the frame's own fix.

So the words are now written to the phone on every keystroke and restored when the note sheet opens, and only a pin the record actually ACCEPTED clears them. A refused pin, a backgrounded app, a sheet closed by a stray thumb, or a bug nobody has found yet — the sentence is still there when you come back.

Now four pages go out at once, the walks query rides with them instead of queueing behind them, and the walk thumbnails are harvested from rows the loop already had in hand — one query fewer than before the thumbnail feature existed. Same data, same shape on the wire.

It pans and zooms, it carries every placed record as a mark, and it opens on whatever job you were looking at — filter history to a project and the map is that project's ground.

And the 3D ground is back, for the reason Kymani gave: a photograph proves what was in the frame, standing in the place proves what was around it. Any frame the phone stamped with a fix now offers to stand where it was taken — Google's photorealistic tiles seated at that exact spot, drag to look around.

This is not the old world coming back. That was 3,890 lines of beacons and walkers and a memory carousel, and it was deleted on purpose. This is the part he actually asked for and nothing else: no snapshots are ever stored, no second basemap is composited with it, and Google's own live attribution is printed unmodified — the three rules that let us show it at all.

The clerk's read and the code reader's findings now sit on the WORKER screen, under the camera. Every finding prints its article and how many frames it rests on, because a finding that cannot cite a frame and an article is dropped before it is ever filed.

These records are deliberately excluded from every history surface, so without their own door they are invisible. Now they have one, and a test that fails if it closes again.

About twenty thousand lines came out of the app in two commits. What stayed is what other things still use — the typing panel, the skin the signed-out page draws, and the shared types.

The shop window at /tradesboy now shows the real app instead of the machine, which is the point of a shop window.

The whole test suite is green for the first time in a week. Four of the reds were a spec for an on-glass keyboard that had already been removed two days ago; a test for deleted code is just a light that is always on.

WORKER is the job you hold, the camera you can set down, today's lines, and eight ways to put something into the day by hand. HISTORY is everything the record kept, one search field, with the map of a day one press away.

Back moved to the top-left, where no phone has ever drawn its own buttons. That was the third time in two days a control was unreachable at the foot of the screen, and the fix is structural: nothing operable is put down there again.

The filters that used to stack six rows deep before showing a single record now appear only once you turn one on. And words left the square grid — a daily report gets the full width instead of four truncated lines.

Nothing in the engine moved. Capture, upload, the ask stream and every tool sheet are the same code they were yesterday; only the face changed.

SUMMON opens the CAMERA. Every one of the eight tools was already on the viewfinder, which is what took SHOOT off home - handing the worker a photo, a note, a measure for the days task is just using a lens. And the other half of summoning is leaving it somewhere you are not, so the viewfinder grew SET IT DOWN - A WORKER WATCHES: the camera is in your hand, the job is already chosen, and you put it on the pole from there.

HISTORY absorbed the rest. You ASK the record, you see WHERE on the record, and JOBS was always its own JOB dial - so those three sit small under the head. SETTINGS rides with them because it is the only thing that is neither.

Nothing was deleted and nothing orphaned: every screen that was a door is still one press from one of the two. The specs were rewritten to match - pad-home 6/6 with a test that opens the camera and sets it down, pad-shoot 7/7, pad-map 4/4.

The apps own header was drawing UNDER the clock and the battery - two rows of text on one line. env(safe-area-inset-top) reports 0 in that WebView, so the 10px floor could never clear a 24 to 32dp Android status bar. The floor is 32px now, and max() means a device that DOES report an inset still wins.

WorkerShift kept its OWN private copy of the A/B hint row, so it went on printing B BACK after every other screen had stopped - on a machine with no B. It states the verb now and BACK is a button that does exactly what B did from that phase.

And its columns were vertically centred, which was right inside a Game Boys short window and strands the content in the middle of a void at full phone height. They start at the top now, where the eye does.

The way out is a filled orange button with a thumbs hit area, not 10px of grey print. That matters because @capacitor/app is not installed, so nothing of ours can register a hardware back listener inside the APK - the on-screen way out cannot depend on the system one reaching us.

A sentinel history entry is kept while there is something to back out of. The systems back pops it, the pad goes up one screen and re-arms. When there is nothing left to close - home, nothing open - the sentinel is deliberately NOT re-armed, so the next back leaves the app the way it should. Never trap a man in his own phone.

And the on-screen one: the crumb was pressable but still looked like print about where B went, and B is gone. It wears a border now and reads as the control it is.

Proved with a test that opens HISTORY, presses the browsers own back, and asserts it landed on home still inside the app rather than navigating away.

Every one of them is gone now. The crumb is a real back control you press, with a thumb-sized hit area over a hairline row. padKeys stopped printing A VERB / B BACK and prints the verb with a pressable BACK. The feet on READ, TASK, MAP, DEX and the shoot strip say TAP TO OPEN IT rather than A OPENS IT. And THE FILE head says 613 instead of 1/613 - a cursor position out of 613 means something when you step one at a time and is noise under a thumb.

His screenshot also settled the thing I was most worried about: 613 rows on the real record. The two tests that saw an empty file were the harness, not the app.

The suite went from 11 passed / 37 failed at the start of the night to 29 passed / 8 failed. The eight left are two QWERTY behaviours, two harness ledger mocks and four push-to-talk mic tests - none of them navigation, and none of them mine.

So when THE FILE is narrowed to one job on one day, that day now draws itself above the frames it is made of: the walked line, and every placed row as a tick on it. Same PadMap, same dayLineOf the map page uses - no second implementation.

The MAP door is still on home and I did not pull it, because the map page still does three things the file does not: the region and towns view, FIND A PLACE, and the live map with the compass. Deleting the door today would delete those with it. Say the word if losing them is fine and it is one line.

And THE FILE has a search bar. A record you can only walk backwards through is a shoebox; words are how a man looks for a thing he half-remembers. It matches the job, the note, the label, the kind and the day at once, and every word you type has to appear - so pole redland narrows instead of widening. It is touched rather than walked, deliberately, so the row contract the D-pad depends on is untouched.

Also fixed: the shells painted HISTORY key went with the costume, which broke the file spec at its door. HISTORY is the second door on home now, which is a better door anyway.

No ripping was needed. The tablet body had already proved the app does not need painted keys: it has none and works by touch, with a back door on the crumb row. So the shell simply stops being drawn and the glass takes the whole phone. One constant, NO_SHELL, so putting the costume back on is one word.

The boot ceremony went with it. The wordmark falling from behind the bezel with a two-note ding was the most Nintendo thing on the glass, and with no bezel to fall from behind it was just a splash screen standing between a man and his work. The record opens straight away now. The full-screen toggle went too - with no painted body there is no other body to swap to.

What is left of the flavor and was NOT touched: the pixel font, the LCD wash, and the whole sprite and slime layer. Those are a separate pass and a separate decision.

One bug of mine, caught by the tests and worth keeping: I first named the door THE RECORD, which is also the header line at the top of home. Two things on one screen with the same name is ambiguous to a person, not just to a locator - every spec boot matched two elements and died. It is HISTORY now, which is his word anyway.

And a finding: the pad suite was ALREADY red before any of this. Specs written yesterday assume ASK is the first door - untrue since SUMMON landed the night before - and that the on-glass keyboard still has a SPACE key, which it lost when it went QWERTY. Navigation and stale strings fixed across pad-ask; the suite went from 11 passed to 32.

AREA now prints the street under the overhead, with the fix beneath it. The geocoder's reverse mode already existed for the address elect, so nothing new was built. Checked against real captures before wiring it: 8000 Needwood Road Derwood, Redland Road Derwood, East-West Highway Bethesda — real streets, from his own frames.

Cached by fix rounded to about eleven metres, so paging across a set of frames shot on one corner asks the geocoder once rather than once per photo. A lookup in flight says so; one that was never started (the demo pad) shows the coordinates alone instead of claiming to be reading forever.

FIRST: the geocoders return NOTHING for an intersection. Photon answers "Crabbs Branch Way and Redland Road" with an empty list, both ways round — so the search fell through to whatever coarse thing the words happened to match, which is why two phrasings of one corner came back identical. Each street on its own resolves fine, and a street comes back as several points ALONG it, so the crossing is now solved as the nearest approach between the two sets. Measured on his corner: the nearest pair sits 310 m apart and both phrasings land on 39.11944, -77.15958 — the same point to the metre, whichever way round he types it.

SECOND: it never said which address it had picked. The candidates are kept now, ◂ ▸ walks them, the head says MATCH 2 OF 5, and the coordinates are printed under the label. Two phrasings of one intersection landing on the same photos is correct — it stops being confusing the moment the screen admits which point it chose.

THIRD, and this one would have made the whole feature useless: his forty-two frames at that corner sit 433 FEET from the solved point — every one of them outside the 400 ft ring, including one whose note reads "install at intersection of re…". A geocoded intersection is only as good as the streets it was solved from, and a search that answers "nothing" while the man is looking at the photos he took there is worse than no search. The ring is the headline now, not the filter: everything within a quarter mile comes back, nearest first, each row wearing its distance, and the caption says how many are actually within 400 ft. The numbers let him judge; a hard cut just lies confidently.

FOURTH, caught on the way out: sorting by distance quietly broke the date span, which was reading the ends of the list — the nearest and furthest capture — and calling it a range of days. It is taken from the dates themselves now.

It is a bar at the top of the map now: ⌕ FIND A PLACE, visible and tappable, where a search belongs on a map. The hardware key still opens it, and the bar is what tells you the key does anything.

Two layout faults caught by looking rather than assuming. Put at the FOOT it drew straight on top of the map's own footer — two lines of type in the same place. Moved to the top it fit, but at 40px tall it pushed that footer down into the crumb row on a short glass. It costs a line of type now.

Nothing else moved. Same props, same handle, so every caller of openKeys is untouched: A still commits, B still cancels, ENTER sends and SHIFT+ENTER breaks a line. The pad's global key handler already stood aside for a focused field, so arrows and letters reach the box instead of walking the cursor underneath it. And padH — the machinery that shrinks the pad when the keyboard eats the bottom of the screen — is load-bearing again rather than a leftover.

One bug found by watching it rather than trusting it: the ENTER that opens the panel arrives at the textarea a moment after we focus it, and left a newline sitting in an empty box. Leading whitespace can no longer be typed at all, which is right for a question or a note.

THE MAP CAN BE ASKED ABOUT A PLACE. "Allow me to search in the map for a google maps location and show me all captures ever at that place." SELECT on the map opens a search — no new door, since the job page just lost four of those for being doors — you type a place, and the answer is every capture within 400 feet of it, newest first, with its note, its job and how far off it sits.

This is the first query in the app that does not belong to a job. It asks the GROUND, not the folder. Measured on the real record before shipping: the densest 400-foot ring holds 79 captures across two days, and 78 captures sit in a ring that spans more than one job name — so a corner you worked twice under two different jobs comes back as one place, which is exactly the point.

No new API and no new table: /api/sites/geocode already turns words into a point (it is the address elect's own search), and the pad already carries every capture's position. The whole thing is a distance filter over what was in hand. 400 feet is a building and its lot — wide enough that a fix from inside a structure still lands, tight enough that the job next door is a different place.

Now the spot under your fingers stays under your fingers. Pinch on a corner and that corner is what comes up; slide both fingers and the picture comes with them; double tap on a detail and it lands there, not in the centre.

And it can't be shoved off its mount any more — the picture's own edge stops at the frame's edge, so you always have something to look at.

The reason it needed care: a sideways drag already meant 'next frame'. While you are zoomed in, that same drag has to mean 'move the picture' instead — otherwise the moment you try to look at a corner, the photo walks away from you.

And the pinch itself was walking to the next frame. Lifting two fingers looks exactly like one long sideways swipe, and the machine was reading the zoom level one render too late — during a quick pinch it still believed the picture was at rest. The scale is now true in the middle of the gesture, and two fingers can never be a swipe.

The half that was missing: talking to it while it watches. And it could not use ASK - that answers from the record, and a running shift HAS no record. Its capture rows are written by the box in the shift tail, when the shift ends. So a live worker asked through the record would truthfully say it knows nothing.

So it asks the one thing that exists while a worker is on the clock: the frame it is looking at right now, the eye the box republishes every few seconds. New route /api/worker/ask - owner-auth, fetches the live eye, hands it to the model with the question. The law is the same one the code reader keeps: answer from the picture or say plainly you cannot see it from there. A camera that guesses is worse than no camera, because the whole reason he set it down is that it was there and he was not.

On the monitor it is one line above the tools - ASK THE PHOTOGRAPHER WHAT IT SEES - and the words come from the on-glass keys, never the phones keyboard. Honest limit: the watching phase cannot be rendered without a live shift, so this is typechecked and lint clean but unseen. Starting a shift is the test.

SUMMON is not a menu. It looks for the camera and starts a worker on the job you hold. If there is no camera linked, the pairing screen appears - as the obstacle in the way, never as an option you picked. That behaviour already existed inside the worker; it just had no front door.

Nothing was deleted and nothing moved sideways. ASK, SHOOT, THE DAYS, MAP, JOBS and SETTINGS are all exactly where they were, one row further down. If the one door proves right in the field we take out the scaffolding behind it; if it does not, we lost one row.

The row count moved with it - a pad screen whose rows ternary disagrees with its list has a dead D-pad, which is a trap already written down. The home spec gained a test that proves SUMMON actually starts a worker rather than merely printing a word, and the full pad suite is 27 green.

This is the MANUAL half, proven on the worker that already exists before a refactor is earned. While a shift is running - the camera on a pole, you on the ground - the monitor now carries three buttons that act on what it is seeing right now. KEEP THIS banks the frame. READ PANEL banks it and reads it. CODE CHECK runs the code reader over the day.

Every one rides an endpoint that already existed: /api/sites/photo banks the frame and hands back its id, /api/panel reads that id, /api/sites/code-read reads the day. Nothing new on the server, and nothing here can disturb the shift - they are additive fetches and a failure says so and leaves the worker watching.

Honest limit: the watching phase cannot be rendered without a live shift, so the buttons are typechecked and their route contracts read from source, but unseen. Starting a shift is the test.

A real microphone is the one thing a headless browser will never have, so there is a fake recogniser in the tests now that behaves like Android's: interim results, finals, and ending on a pause. The race is reproduced by dispatching both presses in ONE tick, which is the whole point — do it with an await between and the old code passes, which is exactly why this survived being looked at.

CLR joins the board. "I had a way to just clear the input line if I wanna restart the note." DEL is a letter at a time; dictation fills a line in one breath and sometimes it comes out wrong.

And the tool strip could not be reached. The scrim over the viewfinder is pointer-transparent so it never steals a press from the picture — but that also meant the strip itself could not be dragged, so only the first four tools were ever reachable. The rows take presses now. The strips also stood aside when a sheet's keyboard is up: that board renders inside the glass, and the strips live in the layer above it, so they were painting across the keys and eating presses meant for letters.

This has been true since the skin was built. It was survivable the whole time because the brow was sixty pixels of plain shell and the status bar simply sat on it, which reads as a phone showing its own chrome over a machine. It stopped being survivable this morning, the moment the glass was moved up to twenty pixels from the top — the same change that finally gave him the screen he wanted took away the shell that had been hiding the fault.

The head inset is measured now, exactly the way the foot's already was, and the machine is seated below it: it starts at the inset and its last row of shell lands on the foot. Both edges of the phone, honestly. The one thing a desktop browser will never hand you is a real safe-area inset, so the seating arithmetic is checked directly against every machine at four different insets — and those checks fail on the old code.

The whole arsenal is printed along the foot now — every tool you have, the open one filled, the one under the dial lit. Turning is free. A is what commits: A on a different tool takes that tool, A on the lens you are already looking through is the shutter, and the strip says which of the two it will be. There is a test that walks the dial across the arsenal and back and fails if a single workflow starts.

The two blocks on the viewfinder were also separate floating layers at overlapping offsets, which is how the job's name ended up sitting under a row of chips. They are two ordinary stacked columns now — one at the top, one at the foot — so nothing can land on anything else.

AND EVERY ADDRESS CAN BE DRIVEN TO. "Allow from the address list to route in Google Maps to jobs." A jobsite address you cannot navigate to is a string. Every door — on the job's page and in the full address list — carries a ROUTE key that hands off to the Maps app. One helper writes the URL, so every list opens the same route.

THE BOTTOM CORNERS. Fixing the top ones yesterday only fixed half the fault: the band of shell below the screen starts exactly AT the bottom of the hole, so the well's painted bottom curve was never drawn anywhere and the paper ran square into a rounded bezel. It now reaches one radius UP, the mirror of the lid band reaching one radius down. Both curves on screen are the illustrator's again.

THE STICKER PATCHES. The crumb line and the screen key carried their own fill of the panel's colour. That was invisible until the LCD matrix moved into the panel's BACKGROUND — after which a solid patch of the same colour reads as a label stuck over the grid. They are transparent now; the panel's own bottom padding already kept content clear of them.

AND THE KEY THAT DID NOTHING. The new deck has two small round keys and only one had a job. The spare one folds the machine back to the handheld — a real key for the thing the glass was spending a row on. The printed key stays too: an unlabelled round button is not a way out anybody can SEE, and not being able to get back is the exact trap this machine has already fallen into twice.

The thing actually paying for the screen was the SPEAKER GRILLE. It is pure decoration, it sits BELOW the buttons, and it was costing four hundred pixels of deck height to say nothing. Take it out and the deck has room to breathe without shrinking a single control: the d-pad, A and B, the pills, the light — all exactly the size he approved — now sit in one shallow strip. 674px of glass against 608, with the brow down to 20px, so the picture starts at the very top of the machine.

Worth recording for the next time: a control is expensive in DECK HEIGHT, not in pixels. Anything that stacks BELOW the buttons costs the screen directly. That is why the grille had to go and why the arrangement above it did not.

The glass fills the hole SQUARE now, and the shell's own band reaches one radius further down so the ILLUSTRATOR'S rounded corner is painted back over it. The curve on screen is the drawn curve, not a CSS approximation of it — which is the whole premise of an emulator skin and was quietly broken.

"The d-pad and buttons could have better placement." They were being cut by the edge of the shell: the d-pad's dished recess ran off the left side and the buttons' raised pad ran off the right. A control clipped by the shell edge is the single thing that stops a machine reading as a real object. The deck was repainted with margins as the first rule — every control, and the whole of its recess, sitting well inside the plastic with clear shell around it — and then compressed at its plain bands as usual. 608px of glass, 353px of deck.

AND THE SHOOT PAGE IS GONE. "The one with the character at the top, the enemy card, then the task list, then the tools — I do not want that one anymore. But before deleting it, make sure you transferred everything over to the viewfinder: I can select the tool, upload to a task if I wanted to, or just raw dog it to the job site." It was a page standing in front of the camera doing three things the camera could do itself. All three moved onto the lens: the tool's name with ◂ ▸ to turn it, the job's open lines as chips you touch, and NO LINE as a chip of its own — a shot filed to the job itself, chosen rather than defaulted. SHOOT now opens the lens with nothing in between.

The test harness had to grow a stand-in lens for any of that to be checkable — it only ever recorded which tool fired, because the real sheets need a camera. The page's old guarantees were rewritten against the viewfinder rather than deleted with it, including the one that matters most: every one of the eight tools carries the line it was aimed at, which silently failed for months when only PHOTO did.

A AND B ARE MOULDED NOW. "Fix the A and the B on the buttons, they look so fake." They were bright white pixel letters with a drop shadow pasted flat onto a photoreal button — two different worlds touching, which is the whole tell. A real key's letter is the same plastic and you only see it because of how light catches the recess. So: the shell's own typeface rather than the LCD's pixel font, dark ink at low opacity, one highlight beneath.

THE JOB'S PAGE IS A DEX ENTRY. "I literally want a simple Nintendo list of share, tasks, file, and map." It is now the name, every address the job has or was noticed at, and four rows. Gone: the keeps list, the on-file readout, the next-task preview, the days chip beside the name, and the two-tier ASK/SEND treatment. ASK came off because the record is asked from HOME where the question reaches every job; HOLD came off because standing on a job's ground already picks it up.

SHOOT OPENS THE LENS. It was a page ABOUT shooting with the camera one press further on. Now the viewfinder opens, and the job, the line you aimed at and the lens's own name ride ON it — white, orange, one word each, no paragraph about what a lens is for. ◂ ▸ put the open lens away and bring the next one up, keeping the aim.

AND THE JOB STOPPED FLIPPING. He watched the held job cycle between two sites on its own and guessed at an address bug. It was not one, which is exactly why looking at addresses would never have found it: two jobs on the same street sit a few hundred metres apart, the machine took whichever was NEAREST on every GPS fix, and the gap between those two distances is smaller than ordinary GPS noise. So it flipped on the wobble, and the flip auto-held the job. The ground you are on now KEEPS you until a rival is meaningfully closer. There was a second source too — with no fix at all, the shown job fell through to "the first active one in the list", a derived answer recomputed against an array the record re-sorts as it loads. Whatever the machine settles on, it now holds. Both are locked by tests that fail on the old rule.

So the machine was repainted again: the screen now takes three quarters of the face, the strip along the foot is shallow, the d-pad hugs the bottom-left corner and A and B hug the bottom-right, and the keys nobody presses in a hurry — the two pills, the work light, the lamp — sit in the dead middle where a thumb never has to reach. Measured on a Razr: 711px of glass, against 593 for the deep deck and 483 for the handheld. The record shows five rows of frames at a glance now instead of four.

Every hotspot was then recalibrated against the machine's own render rather than against a grid drawn over the art — twice today a control's letter came out sitting beside its button because a coordinate was read off the wrong scale. The rendered machine is the only measurement that cannot lie about itself.

The first instinct was to shove the painted controls down by stretching the plain shell above them — the same trick that lets these skins fit any phone. It does not work here: measured, that band carries the screen well's own shadow, a real vertical gradient, and stretching it five times would have smeared a stripe across the machine. Composition belongs in the art, so the art was repainted: one recessed control box running from just under the screen all the way to a thin lip at the foot, every control spread evenly through its height, the light key and the lamp as a matched pair in the bottom corners with clear shell around them, and the wordmark centred between them.

It costs about thirty pixels of glass and buys a machine that looks made rather than assembled. And the new art went out under a NEW FILENAME, which is now simply the rule after this morning.

His record agrees, and the numbers are not close. Measured across the whole thing: SHARE/report 13 uses spanning Aug 12 to Aug 31 and still going. ASK 7 uses, all inside the four days after it shipped. TASKS 6 uses over two days. DAYNOTE 11, stopped Aug 25. MISSION 5, stopped Aug 27. Everything gets a few days of poking and dies; share is the only thing with three weeks behind it.

The reason is in the verbs. LOAD JOB, TASKS, THE FILE and MAP are all BROWSE verbs — they carry you somewhere to look around, and looking around is not a thing anyone does on a jobsite. ASK and SEND are TAKING verbs: one gets something out, one hands it to somebody. That is why share is the only door on that page that has ever felt right.

So the job page is two verbs now. WHAT DO YOU NEED? asks the record with this job already in hand. SEND IT TO SOMEONE makes the link. Under them, one quiet strip keeps TASKS, FILE, MAP and HOLD reachable without being the shape of the screen. Nothing was deleted and nothing became unreachable.

LOAD JOB became HOLD and moved into the strip, because the holding law already picks a job up when you arrive on its ground — the button was for something the app does by itself. It survives only as the deliberate swap from somewhere else. THE CLERKS left this menu entirely; the two clerks keep their COMING SOON on SHADOW's roster, which is where a worker belongs anyway.

The ask is scoped, not duplicated: the same box and the same answer surface as everywhere else, with the job passed in as an argument. The head names it — ASK THE RECORD / REDLAND @ CRABBS — instead of claiming EVERY JOB while reading one. Typing still happens on the glass keyboard; the system keyboard never appears.

One real bug found on the way: the Dex page carried minHeight 0, so on a short glass it surrendered every pixel to the rows below and the job's own name rendered as a clipped sliver. It keeps enough for the name, the address and a line of the record now; the strip gives way first instead.

Two fixes. The real one: the filename now carries the design (skins/tbt-deck.webp), so a redraw can never be served an old picture again — rename the file when the art changes, always. And a forced purge, service worker v17, because the phones that already have the old copy cannot know any of that. That is the fourth time a stale cache has made a shipped change invisible or broken, and the first time it made the machine look physically wrong.

And a check that would have caught it: tests/pad-skin.spec.ts opens the shipped picture itself, reads its real dimensions out of the file header, and fails if any skin's declared canvas or hole no longer describes the art it names. Verified by swapping the tablet's art for the clamshell's and watching it fail.

So TB-T is now TB-001 rebuilt around a tablet screen: the same shell language, the same canvas, a screen that swallows the top two thirds, and the WHOLE constellation — d-pad, A and B on their diagonal, the two pills, the light key — gathered into one shallow recessed box along the foot. Measured on a Razr: 626px of glass against the handheld's 483, up 30%, with every key still under a thumb. A little less screen than the bare slab, in exchange for still holding a machine.

The soft A and B that were bolted onto its chin this morning are deleted — it has real ones now. And there is only ONE table of what a painted key does, shared by both bodies, because two copies of that is exactly how a key ends up meaning different things depending on which shell you are holding.

One real bug fell out of testing the new deck: a pressed key kept the focus, so the next hardware Enter fired both the global handler AND a second click on whatever you last touched — press DOWN then Enter and the machine opened a frame and armed its delete in the same beat. A painted key lets go of the focus now.

And the tool grades itself with no tape at all. Walk out, come back to where you started, and the gap between your first and last point is pure accumulated error over the whole distance - the surveyors closed traverse. The result says it plainly: you walked 93 ft and finished 9 in from where you began, 0.8% over the whole walk. Anyone can repeat it in two minutes, which is the only kind of accuracy claim worth making.

The AR markers you can SEE through the camera are a different job: the ARCore session is headless - offscreen EGL, no camera view, no anchors - so seeing them needs a rendering surface and a new APK. Everything above needed neither.

It is not that the readers failed. They work — the electrical one caught SO cord staged as fixed wiring and cited 400.12, which is a real catch on a real job. It is that the app now has five words for roughly one idea: a thing that does work on your record for you. VOLT, SHADOW, the crew, the party, and now the clerks. A fifth door does not help a man who cannot find the first four. This waits until the app settles on one word for a worker.

What COMING SOON actually means here: the row keeps its place on the job's entry menu and says so plainly instead of vanishing, and pressing A on it does nothing. Same on the PARTY roster — THE CLERK and THE ELECTRICAL CLERK stay named under THE NIGHT and read 'Coming soon'.

Also switched off: the beat that fired on every job load, the push, and both night crons. That last one matters — nothing in the app shows what those readers file, so running them nightly was spend with no surface.

NOTHING WAS DELETED. The screen, the row model, both readers, the evidence hydration and the marker map are all intact and typechecked. One flag brings it back: CLERKS_SHELVED in pad/base.ts, plus the two cron entries written out in full inside pwa/vercel.json so nobody has to remember the schedule. Every shelved door is marked CLERKS_SHELVED in the code.

It polls four times a second now: how far so far, whether it is tracking, where you are and which way you face. Your path draws itself as you walk it - seeing your own line appear is what tells a man the thing is really watching.

And the result carries a receipt, the same move as the camera one: HOW THIS WAS MEASURED says the phone motion tracking watched the ground go by, not GPS, and what that is worth against GPS 10 to 15 feet. Under it, TRACKING says whether it held the whole way or was lost and regained - and if it was lost, it says plainly that anything walked during the gap is not in the number and to walk it again if it matters.

Both states seen on screen before commit, not assumed.

The lens is gone from the rail, with its handler, its ref and the dead helper behind it. Eight lenses now, and the tool button counts 1/8. NOTHING else went with it: the twin viewer, splat_url, the signed-out landing room and the box pipeline are all untouched - this is the lens coming off the camera, not the technology leaving the building.

The pad suite was updated to eight and run: 29 of 30 pass, including every one of the eight tools carrying the line it was aimed at. The one failure was a dead spec pointing at /reconstruct/[id], a route deleted with the old pipeline generation - removed, so red means red again.

The memory page is the archive. That is the entire reason it exists: so tomorrow's clerk starts where you left off. Sending ten days of raw lines beside it was paying twice for the same knowledge. So the corpus is now today's work and the open tasks, and everything older arrives through /memories/job.md, which the clerk reads first and writes back. 21,257 tokens became 4,514.

Then a cache breakpoint on that corpus, which ASK has had since August and the night workers never did. The record does not change between turns, so it is written once and read at a tenth after. Measured on the same night: the cache is landing, 20,416 tokens read cheap.

Then the model. Reading a day back is summarising, so the clerk was tried on Haiku against the same corpus and the same memory page — and the Haiku finding was the BETTER of the two. It named the overdue task in his own words, flagged the Sept 1 pole with no photos, said the day was staging rather than install, and cited nine frames with no stray markers.

Measured, same job, same night, same quality: $0.2026 before, $0.1157 with the day-only corpus and caching, $0.0202 on Haiku. Ten times cheaper. Three active jobs is about six cents a night rather than $1.20. And every run now prints its own bill to the log, priced by the model it actually used, because the old comment said "pennies" as a guess and nobody could see it was wrong.

THE CODE READER DOES NOT GET THE CHEAP MODEL, and can no longer inherit it by accident. It cites the NEC, where a confidently wrong article is worse than silence. It used to fall back through BRIEF_MODEL, which would have quietly demoted it the moment the clerk's line changed; it asks for CODE_MODEL and falls back to Sonnet on its own now.

The other half: "it's so hidden in our app." It was worse than hidden. The pad fetched the night finding on EVERY job load and wrote it into state that no screen paints — fetched and dropped on the floor. The only trace was a beat saying THE RECORD READ ITSELF LAST NIGHT, which tells you a job ran and never that the electrical clerk flagged a cord, so there was no reason to go looking.

So the beat says what was found — THE ELECTRICAL CLERK FLAGGED 2 THINGS — and the finding now taps you on the shoulder. A night finding fires a Web Push whose body is its first sentence, and the tap lands on /?read=<siteId>, which opens THE CLERKS on that job. That is the worker law from August applied to a worker that had been left out of it. Note it only reaches browsers that have armed push, which happens at a worker clock-in — nothing is armed yet, so this is wired but not yet proven on a real phone.

A walk now carries two: PATH, what you walked, and STRAIGHT FROM START TO FINISH, corner to corner, computed from the trail its own first and last point. On a straight run they agree and either is the run. When they disagree the route bent, and you can see by how much instead of trusting one number blind.

Nothing is calibrated away or fudged. Both numbers are shown and the man holding the tape decides which one he wanted. No new APK - the trail was already there.

And the screen rendered it as the words "1 FRAME" and nothing else. Kymani: "anything that says it has data MUST have its data inline." He is right, and the reason is worse than a layout choice. That finding rests on a DAYNOTE — no photograph, no media at all. Its evidence is the sentence he typed at the end of a day: "Tomorrow, bring both reels of So for camera install." The screen was hunting the pad's ledger for a thumbnail that does not exist and had nothing to fall back on.

So the cited captures are hydrated on the server and travel with the finding — lib/night-evidence.ts, used by both the stored night read and a run you press yourself, so the two can never describe the same capture differently. Under every finding now: the photograph when there is one, and ALWAYS the words — the note the tradesman typed, or the machine's read of the frame, or "no note" said plainly. A capture with no picture gets a dashed NOTE tile instead of an empty space.

The page also stopped being an endless scroll. It opens on the two clerks BY NAME with what each of them found as a number — THE CLERK 4, THE ELECTRICAL CLERK 2 — folded shut. A or ▸ unfolds one, ◂ folds it back, and folding walks the cursor home so it never ends up standing on a row that no longer exists. A clerk with nothing to say still gets its name and NOTHING beside it, because seeing the whole staff at a glance is the thing a scroll can never tell you.

Two bugs the check caught on the way. The code reader writes its markers inline too, so [C74] was printing as text in its findings — a marker is a thing the pad turns into a photograph, never a thing it prints. And a MoCo job number runs 46 characters without a space, which made the whole glass scroll sideways; every line wraps anywhere now.

COST, measured rather than guessed, because the route's own comment claimed "pennies" and was wrong by an order of magnitude. Vitronics' ten-day corpus is 21,257 input tokens, and the memory-tool loop resends the whole conversation every turn, so one night read is about $0.20 and the code read about the same. Three active jobs is roughly $1.20 a night. The obvious cut is prompt caching, which ASK already does — the corpus is identical across those turns, so a cache breakpoint would charge the repeats at a tenth. Not done yet, and the comment now says so.

A PICTURE IS HELD, NOT PASTED ON. "It's like a sandwich window with a manila border, photo, and another manila section." So the ground under a frame is paper on purpose, and the space above and below the picture is not dead letterbox any more — it is the mount, and it carries the words: when and where along the top, the note along the bottom, the way a print is captioned. And swiping works: drag sideways to walk to the next frame. That took two bugs to land — a swipe ends in a click, which was closing the picture it was trying to move past, and dragging across a photo starts Chromium's native image drag, which silently swallowed the whole gesture.

HOLD TO TALK. "WOW IT WORKS I LOVE THE MIC — however can you make it a CLEAR input modality, like a big hold to push to talk button?" It was a little key hiding among the letters, which reads as punctuation rather than a way of working. It is the widest thing on the screen now, sitting above the line with the board below, and it behaves like a radio: hold it down and talk, let go and it stops. Nothing is captured when your thumb is off it, which is also the honest thing to do with a microphone.

And the small ones that add up: the day rail's chips wear each day's own cover frame, because you recognise a day by what it looked like long before you know its date; a frame with no picture now says what it IS in the machine's type — PAPER announced itself as nothing at all, and a note dumped its words into a 90px square as body copy, which read as a glitch.

A WAY OUT OF THE FOOTAGE. Watching a 360 walk had no exit: footage goes wide, and a wide glass fades the painted shell to pointerEvents:none — which kills the very B key that closes it. The same trap that broke the photo viewer and the capture shutter before it. There is a drawn BACK door on the footage itself now. The rule this keeps proving: every surface that goes wide owes you a door drawn on ITSELF.

THE MATRIX MOVED TO THE GROUND. "Maybe that's the only place the matrix should exist in my app, for flavor — never over content." It was a sheet laid over the glass, so it fell across photographs and type alike: charm charged to the thing you were trying to read. It is the panel's own background now, showing through the empty ground between rows — where a real LCD's grid is visible — and crossing nothing. It had to be a background rather than a layer behind: a positioned sheet still paints over ordinary content.

THE MIC. Speaking beats any keyboard when your hands are full, so the board has one — Android's own on-device recogniser, straight into the line you are writing, live as you talk. No Deepgram, no ElevenLabs, no /api/transcribe, no audio leaving the phone: the Ghost pipeline stays dead. Where there is no recogniser the key simply is not drawn.

AND THE TABLET IS THE SAME MACHINE. "It seems it has less screen space and a different design image than the slab — they should be the same style." Both faults were one mistake: TB-T was painted as a rugged rubber drop case, which is a different object from TB-001's moulded console shell, and its art was pre-stretched onto a freak canvas to dodge a runtime stretch — so on anything but one exact phone it letterboxed and lost width. The new TB-T is TB-001's own shell language, generated with the slab as the reference, on the slab's exact canvas. Measured: the same 304px of glass width as the handheld, and 60% more glass height.

"Could you make photos take the full glass space please? Viewing them in totality is important." A frame drawn around a photograph is furniture — the machine's own bezel is already the frame. A picture now runs edge to edge on solid ground, and its note floats over the bottom on a soft scrim instead of pushing the image into a letterbox. The bonded pair still holds; it just costs the photograph nothing. Words keep their drawn frame, because a page wants a margin.

And the real complaint underneath all of it: "this section is literally the treasure trove of my app but I can't even tell you how often I spend a long time trying to find stuff — search bar is NOT the fix." He is right that it is not. Finding a frame is a LOOKING problem, and the handheld's little window was showing two rows of a contact sheet through an LCD grid. So his own idea got built: opening THE FILE unfolds the machine into its tablet body, the frames go from four across to three and get bigger, and the pixel matrix comes off the album — it is laid over the one thing you are trying to recognise. Twenty-one frames at a glance instead of eight, at nearly double the size, with nothing drawn on top of them. Leaving the file folds the machine back to whatever you were holding; it never touches your setting.

The findings were always a list. The clerk is told to write at most four short sentences, each carrying its own [C#] markers; the electrical clerk files up to three one-sentence findings. The screen was gluing that back into a paragraph. Now the paragraph is cut into the sentences it was written as, one row each, and the cursor walks them like every other list on the glass. A opens the frame the line rests on; on the last row A sends the electrical clerk back through two weeks.

The proof is under each line: the actual thumbnails from the record, the frame count, and for the electrical clerk the article it looked up. The raw [C4][C5] markers are gone from the prose — they were being printed as text, when the whole point of a marker is that the pad turns it into that photograph.

Which it could not do, because the client was throwing the evidence away. /api/sites/brief has always returned the capture ids a finding rests on, and the pad's loader kept only the text. So tonight's Vitronics finding cited five frames and the screen could show none of them. It keeps them now.

And the frames are bound per LINE, not per finding. The night read stores a marker map — which photograph each [C#] actually meant — so the sentence about the crooked floodlight opens the floodlight, not the first photo of the day. Verified on the live record: four sentences, twenty-three markers, every one resolving to a real capture. Findings filed before the map existed still work; they show their frames once, honestly labelled as the frames the whole finding rests on.

The header says when the record was read, or that it never has been. Silence keeps its dignity: a clerk that went through the job and found nothing the code speaks to says so in a sentence, because that is an answer, not an error.

The party screen was already the coherent thing and nobody could see it: it is SHADOW own page, where SHADOW is either WITH YOU (in your hand, talk to it) or ON THE CLOCK (posted on a camera), and the four trades are the moves you post it with. One entity, two states.

So the strip now has one door and it is SHADOW itself, with its name under it - orange while it is working. The operator is just you again, holding the machine, not a button. Talking to SHADOW is the first row of its page, so nothing moved further away, and posting it on a camera is the rows under that.

Caught on screen and fixed before commit: SHADOW · ON THE CLOCK was wide enough to squeeze the job own name off the strip. The label is the name only; working is said in ink and in the sprite run.

The X5 card asks the one question a borrowed camera raises - NOTHING ON THE CARD - off by default, so your own walks behave exactly as they always have. With it on the copy changes to say what is really happening: the stream is the walk, nothing is written to this camera, it runs until the battery does. STOP no longer asks a camera to stop a recording it never started.

What you give up saying it plainly: the 5.7K master, and the safety net of footage that survives a dead phone. What you get is a walk that costs the camera owner nothing and lasts as long as his battery.

Verified both states on screen by booting the card straight into its ready phase; the harness is not in the tree.

"Remove the data tags from existing entries — granted the entry exists in the space it does, it's obvious what it is." Fair: a photo announces itself. The file-type tag, the per-tile clock and the word CLIP all came off the frames. The only mark left on a tile is 360, because that one is not obvious and it changes what A does — you can stand in it. WHEN and WHERE are printed once now, in the foot, for the frame under the cursor, with a ⌖ when the frame carries the ground it was shot on.

"The viewer is kinda crowded af and I can't even see photos well." Every pixel in there was furniture: a fat pad, a caption naming what the picture obviously was, and an unbounded note that could squeeze a photo into a letterbox. The pad is tight, the note is capped at two lines, and one small line under it says the time, the job and whether ▸ will show you where. The picture takes everything else.

Nothing in the entire app called go(party). The PARTY screen - the only place a camera clocks in for a shift, and the only route to the worker and shift screens - was reachable by exactly one accident: open the companion from PLAY, then close it, and its onClose drops you on a screen you were never on. That is not a door.

The operator on the job strip is the door now, with the word CREW under him so it reads as one, and it turns orange and says WORKING while a shift is live. Workers start from the job card, the job card is PLAY, and the operator is you standing on it.

Worth saying plainly: every storage-free capture thing built today sat behind that missing door. The pipeline was never the problem.

The keyboard was an alphabet grid because a Game Boy's is — which is exactly the wrong reason. The thing that has been in a tradesman's thumbs for twenty years is QWERTY, and a machine's keyboard may be pixel-drawn but it may not make you hunt. It is now three staggered QWERTY rows with the key type sized off the glass's own width instead of a fixed pixel size, keys shaped like keys rather than tall slots, and the written line sitting directly on top of the board the way a text field sits on a keyboard — floated up at the top of the screen it read as unrelated to the keys under it. DONE wears the accent, because it sits beside DEL and a wrong press there commits the line instead of fixing it.

And the pinch was real geometry, not taste. The tablet's art is stretched once at build time through its own waist so the app never has to stretch it at runtime — but the first TB-T had corner bumpers that bulged out past its side walls, so pulling the waist long left the machine visibly nipped in at the middle. The new case runs dead parallel from corner to corner with the corner protection built into the wall, and the walls are 12% of the width each. A stretch has nothing left to distort, and it reads as a real drop case instead of a picture frame.

Both crons fire after midnight — 04:20 and 04:40 UTC, which is 12:20 and 12:40 AM Eastern. Both then asked the record for every job that saw work TODAY, computing today from the wall clock. At 12:20 AM that day is twenty minutes old and nobody has taken a photograph in it. So the list of jobs to read came back empty, every time, and the workers went straight back to sleep without touching anything.

Replayed against the live record, all three firings since they shipped: fired Aug 29, asked for Aug 29, picked NO jobs — while Aug 28 held 14 captures. Fired Aug 30, asked for Aug 30, picked NO jobs — Aug 29 held 65. Fired Aug 31, picked NO jobs — Aug 30 held 5. Rolling the clock back six hours picks two or three real jobs on every one of those nights.

Six hours puts the reader back inside the evening of the day it is reading, in either half of the year. It is also why the daily draft never had this problem: its late run is 03:55 UTC, 11:55 PM Eastern, still inside the day it drafts. The night workers are scheduled twenty-five minutes past that line. The rule now lives in lib/work-day.ts, and anything that reads a finished day asks for the day through it.

Then it was run for real against the record, and the night clerk filed its first finding ever — on Vitronics, citing five frames: today was Randolph Rd at Kemp Mill pre-install conduit and the MoCo commissioning checklist for job 115104, a floodlight flagged crooked, conduit corrosion; and the task due today that also covers Wednesday's East Gude/Southlawn double pole shows no alignment work logged at all, so it is behind with a Sept 1 deadline still open. It also noticed that 'close out Redland and Crabs Branch permit' has been typed twice and neither copy has moved for days.

It kept a memory page too — 1,832 bytes of standing notes on that job: which intersections are in play, the POLISCAN and PULS and CradlePoint model numbers, which tasks keep coming back, that Shady Grove and Research has been 'still problematic' since 8/28 with no update since. Tomorrow night's clerk starts from that page instead of from nothing.

The code reader ran on the same job and said nothing, which is its law working — but it is not yet a fair test: on this branch its digest still drops the materials line, so the words code actually speaks about never reach it. That fix is in the other lane and lands with the merge.

Twenty of them are committed now, in tests/pad-home, pad-shoot and pad-map. Run them with `npm run test:e2e` from pwa/.

They lock the rules that were actually broken in the field: SHOOT never reaches the question box, no overlay ever opens on the day, all nine tools carry the line they were aimed at, a shot never ticks a task, the six doors each open what they say, the map prints a bearing with no magnetometer, and LIVE MAP goes in and comes back out.

They drive /e2e-pad — the same component the field runs, out of demo mode, holding a location, recording which tool fired. That route 404s in a real build (verified against a production server); only Playwright's own web server turns it on.

One pre-existing spec, reconstruct-360-e2e, is failing. I checked it against a clean tree before touching anything — it was already red, and it is not part of this week's work.

The four doors above the rule are now one thing: ASK the record · SHOOT to add to it · THE DAYS to walk back through it · MAP to see where it happened. That's physical world memory said as structure instead of as copy.

JOBS and SETTINGS moved below a dashed rule. A job is a LABEL on a memory, not the memory itself — a memory is organised by where and when. The filing cabinet goes under the line.

THE DAYS is the file with nothing filtered: every frame the record holds, newest first, the day's name ruled across it where the day changes. That's PRODUCT.md's own one true line — 'walk back into any day on site' — and until tonight it had no door from home. It was three presses deep behind Settings.

Nothing was deleted. Every door was walked headless to confirm it opens what it says.

This is reversible in one commit if it's wrong.

It now says it, with your own numbers: THE RECORD — 273 frames · 10 walks · 3 jobs · 8 days — and under it, 'Everything you walked past, kept. Ask it anything.'

Days are counted off the ledger, not summed per job, because a day worked across two jobs is one day. Every number is something the record can back; nothing is rounded or claimed.

The site count came out of the header — it was saying the same thing twice, one line apart.

The day used to be a page plus two overlays: SHOOT opened WHAT IS THIS FOR, that opened PICK A TOOL, then a lens. Three screens for one act. Now the page IS the choice. The board lists JUST SHOOT, then every line the job owes, then WRITE A LINE — the cursor picks WHAT the shot is for. One button at the foot holds the tool: ◂ ▸ cycle all nine, each showing its number, its icon, its name and a plain sentence saying what it is. A combines the two, and the line under it says so in words — 'A · PANEL ON THIS LINE'.

ASK came off the day. There were two question boxes; the menu's answers from every job and can be scoped by the question itself ('vitronics on tuesday'), so the second one only cost the day a row.

The menu is five doors instead of seven: ASK, SHOOT, INDEX, MAP, SETTINGS. THE JOB went to the same place as SHOOT — a duplicate one row apart, which is what made the menu read as a pile. TODAY was the FILE with a date on it; the file is still one press from a job's index page and from Settings.

The map answers 'which way' now. A live compass rose sits top-right, and the job under the cursor carries its true-north bearing — the caption reads '6.7 mi · SW'. That half is pure math, so it's right even when the phone has no magnetometer; when there IS no reading it says so rather than drawing a needle that points at nothing. This is the westbound-jobsite problem.

LIVE MAP is on there too: ▴ drops to the satellite bird's-eye of the ground under your boots, ▾ climbs back out, and there's a tappable chip for the same thing. It reuses the day-still path exactly, so there's no second projection to keep honest.

Two pieces of state, two overlays and a relabelling button deleted; play.tsx went from 402 lines to 245. Drove all of it headless: jobs with no lines and with lines, all nine tools cycling and firing on a line, and the map's compass, bearing and live view.

Not done and worth saying plainly: you asked me to delete pages. I checked every screen and they are all reachable and all working — nothing is dead code. Deleting real features is your call, not mine, so I collapsed the menu instead and I'll bring you a list.

First: SHOOT skipped the 'what is this for' beat entirely when a job had no open lines, and pressing a line fired whatever lens the dial happened to be on — no tool choice at all. So the same key opened three different screens depending on state. Now there is one road: pick the line (JUST SHOOT counts as a choice), pick the tool, then the tool opens. Pressing an open line walks into PICK A TOOL with that line already held, because the task question is already answered.

Second, the real one: the line only ever reached PHOTO. The pairing screen offered nine tools and eight of them dropped it on the floor — that is why pairing looked like it worked from some keycaps and not others. The pad now hands the line over once, before any tool opens, and the clip, the walk, the panel read, the part, the splat, the upload, the note and the measurement all hang on it.

A line can hold any of that now, not just pictures. Its page prints FILED ON THIS LINE with what each tool put there. A shot still never closes a line — the check mark is still the only thing that does.

Proved it headless: all nine tools fired against a real line, each one carrying it; JUST SHOOT hands over nothing, so the free shot stays free.

Still on the table and not touched: you said a lot of the pages reachable from SHOOT are unused or shouldn't exist in their current form. That is the next conversation, not this change.

The day's row count was hardcoded to 4. On a job with lines the cursor could not reach ASK, and every row number past the count folded onto ASK — that is literally why SHOOT opened the question box.

ASK was the fall-through at the bottom of the branch, so ANY index the screen did not recognise pressed it. It is its own row now, and an index the day does not own does nothing at all.

Two handlers were fighting over the cursor: one clamped the day to 4 rows and walked sideways on the very keys that turn the lens. Only one owns it now.

The keyboard listener re-registered on a hand-listed set of state, and the shoot flow's own state was not on the list. So pressing SHOOT left the keys holding a stale picture of the machine — walking then moved the day underneath the open roster, and the next press landed somewhere else entirely. The keys read the live machine now, bound once.

Opening a question, or walking off to the board and back, used to leave the shoot flow armed underneath. One verb owns the glass at a time.

Drove all of it headless on jobs with no lines, one line and four: SHOOT never reaches ASK, walking inside a beat never moves the day, and B leaves nothing armed. Ran the same 36 checks against the old code first — it fails five of them, so the checks are real.

Two more bugs in that same view, both visible in his screenshot: a long read could not be scrolled to its end (a centred flex child overflows BOTH ways in a scroller, so the last lines were unreachable), and tapping the words swallowed the tap instead of closing. The text scrolls from the top now, and there is an always-present ✕ that never depends on the shell's keys being live.

Every remaining tool sheet was checked for the same escape: the scan-confirm sheet now paints in the glass with the rest. Note, part, measure, capture, upload and the worker screens were already there.

AND THE BOX HAS A PULSE: Settings prints THE BOX — AWAKE · idle, AWAKE · working, or ASLEEP · n min quiet, read live from the shop PC's heartbeat every 20s. A walk uploads perfectly well to a sleeping box and then simply sits there, so the one thing worth knowing before driving to a site is now readable from the machine instead of guessed at.

The lens banner follows: it reads ON · <the line> while you shoot, so you can see what the shot is filing to without it implying the line is finished.

AND THE GLASS NAMES ITS SHUTTER: an A-marked SHOOT pill sits in the viewfinder — the machine's own key is the shutter, so the screen says so, and the pill is a real target for a thumb that reaches for the screen anyway.

THE ORDER IS HIS (2026-08-31): SHOOT asks WHAT IS THIS FOR? first — JUST SHOOT, or one of the lines this job owes — and only then shows the tools; picking a tool opens the lens in the glass. A job that owes nothing skips straight to the tools. B walks the beats backwards: tools, lines, closed. The chosen line hangs the work on it and still never closes it.

First: pairing only existed if you started from a task row. Now picking PHOTO from the roster offers a second beat — the lines this job owes, with JUST SHOOT — NO LINE as row 0, so pairing is an offer and never a toll. A job with nothing owed skips the beat entirely and shoots straight through.

Second, the sharper one: a shot paired to a line used to PATCH done:true — it closed the line whether you meant to or not. A paired shot now only adds its picture to that line; the line stays open, and the toast says so. Clearing a line stays a deliberate act on the line itself. Proving from a task row still closes it, exactly as before.

SHOOT now takes the whole line (it wears the loaded lens's icon and n/9), and pressing it opens THE ROSTER over the glass: every tool on its own full row with its number, its icon, and a plain sentence saying what it is — PHOTO, one frame into the record; 360 WALK, the X5 takes the whole site in one pass; PART, name it or just shoot it. The row under the cursor opens out to say what it DOES. A non-technical tradesman reads it top to bottom and knows what the machine can do — which is the actual test.

▴▾ walks it, A opens the tool, B shuts the roster. Rows are flex:none so an opened row can't print over the next one.

So the job's page has THE READ. The clerk's line, then the code reader's findings — each one sentence, each with the article it read (400.10, Table 310.16) and the frames it rests on. Press one and the frame opens: the photo the finding is about. Nothing found prints as nothing found, in those words, because silence is a real answer.

And A on that page runs the reader NOW, over the last two weeks of the job — the answer to "what does the code say about everything I already shot", one press instead of one night. Same reader, same bar, same citations; capped at 90 days and three findings.

Every night, for every job that saw work, it reads what the eye wrote about each frame, looks the code up itself — nec_search for the passage, nec_table for an ampacity or fill row — and files at most three findings, each ONE sentence a foreman acts on, each carrying the frame it saw it in AND the article it read. No citation, no finding: that is the whole difference between this and a chatbot guessing at a jobsite. A finding whose frame can't be shown is dropped before it's filed.

Proven tonight against a made-up day, no writes: it caught the temp feed run in SOOW cord through the office wall (400.10 — cords are not a substitute for fixed wiring) and a 60A breaker on 10 AWG copper — it pulled Table 310.16 itself, saw 30 amps at 60°C, and said size the breaker to the conductor or go up to 6 AWG. Then, on a day of a gang box and a pallet of EMT, it filed nothing at all. Silence is the normal night; the one that speaks is the one you read.

It rides the clerk's rails: same cron shape (04:40 UTC, after the night read), same no-migration storage beside the job, and it's served in the same payload the clerk's finding comes in — so wherever the night speaks, the code speaks with it.

So the page is THE DAY. What this job owes you, as real rows — a box, the words, LATE in orange — with the job it files to on a strip above and one fat camera at the foot. ◂ ▸ turn the lens on that camera from anywhere on the page, so nine lenses cost no screen and no menu. The cursor walks the open lines, then + WRITE A LINE, then SHOOT, then ASK; A does whatever it rests on, and on a line the shot PROVES that line — the old "which task?" select is gone, because the page already knows what you aimed at.

The fun does not live in the layout any more; it lives in what happens after a press — the operator swinging, the slime beside the line you're aiming at, GREW TO L10, the crier's box. That is how Gen I does it: the menu is a plain box, the joy is the animation after you pick. Direction picked off a canvas he ruled on rather than a fourth guess.

So a day arrives CLOSED. What stands on load is the day, its count, and its map — the whole job in order, on the ground it happened on, readable in one screen. The entries open when somebody wants that particular day, and nothing else moves.

The map stays OUT IN FRONT of the fold on purpose. Folding it away with the entries would have left a list of dates, which is the thing that was wrong with this page before the maps existed. The map is the summary; the entries are the detail behind it.

The header is a real button, not a div that listens for clicks — it carries aria-expanded and points at the panel it controls, so the fold is announced to a screen reader instead of being a silent visual trick. Verified by build: tsc clean at zero errors, next build passes.

So every day section on the share page now carries that day s own map: the overhead still cut to exactly that day s captures, each capture a dot, and the day walked as a line in the order it was shot. It is the same picture the Trades Boy already draws for its day strip — same /api/sites/look still, same frame math. stillUrlFor was split into stillFrameFor plus a URL built from it, so the overlay and the photograph underneath are centred by ONE piece of math; a dot placed by different arithmetic than the picture it sits on is a dot in the wrong place.

The still was owner-only, which is why the shared page never had ground. It now also answers a valid share key — the same signature and the same expiry the record itself is behind, so the door is exactly as wide as the one already open and never wider. It is bounded to 80 km around the site s own pin: wide enough that no real day is refused (Olney s pins sit 24 miles out), tight enough that a link is not a free worldwide imagery proxy on our key.

It degrades honestly. With no map key on the deployment, or Google refusing the referrer, the dots and the path still draw on plain ground — the SHAPE of the day is ours, computed from coordinates we already hold, and only the photograph is Google s. The footer says so in words rather than leaving a reader guessing, and counts any captures that have no position instead of inventing them onto the map.

Verified by build, not by eye: npm ci to the locked dependencies (an earlier npm install had drifted the Anthropic SDK and invented seven phantom type errors), then a clean tsc at zero errors and a full next build. NOT yet opened against the live record — no route from the sandbox to Supabase — so the first real look is the proof.

And the armory: twelve rows stacked in a column the width of a thumb is a list you read, not a thing you wield. It holds ONE now — the icon big, the name under it, and n/12 above — with arrows either side and the d-pad still turning it. The page beside it already says what the tool does, so nothing was lost but the scrolling. All twelve cycle: the nine lenses, then the three plays.

One thing his own screenshot showed: the keyboard stayed up after sending, so the answer arrived into a third of the glass and cut off mid-sentence. Sending is done typing — the input now blurs on Enter, on home and on the job's own screen, and the answer gets the whole screen.

Now every cited frame appears as a thumbnail strip right under the answer. A walk frame is marked WALK and opens the footage at its exact second; a photograph opens full-glass carrying its field note, because a photo and its note are a bonded pair everywhere. Four frames at most — proof, not a gallery.

The viewfinder's mode dial is deleted, and with it the last of the menu tree: the armory already picked the tool before the camera opened, so a lens that asks you to choose again is the same problem wearing a different hat. Gone are the dial strip, its mode descriptions, the turn logic, the dialRef plumbing in the page and the shutter's mode branch — not hidden, deleted.

And the close key can no longer be cropped. With the glass filling the phone while a lens is up, the camera's chrome now clears the phone's own status bar instead of sitting under it.

Now the question is READ for scope before anything is fetched (lib/ask-scope.ts). It resolves the JOB it names against your record's own names, nicknames and addresses, and the DAY or span it names — today, yesterday, a weekday ('tuesday' = the most recent one), last week, last 30 days, 'aug 26', '8/14'. Both become REAL filters: a dated question searches that window however far back it is, instead of stopping at the newest rows.

Measured against the real thing: 'what did we do at vitronics on tuesday' now resolves to Vitronics + TUE AUG 25; 'show me the panel at redland aug 26' to that job on that day; 'purple line 8/14' to that job on that date; and a question that names neither still searches everything.

And the glass says what it read: three chips under the question — the job, the day, and how many captures were actually searched. No more guessing what an answer covers.

So the first thing on the glass is now ASK, and it answers from EVERY job at once — the index of everywhere you have been. It answers RIGHT THERE on home; no trip to the encounter first. One press from opening the app to a question box, and the proof door still lands you at the second of footage that proves it.

SHOOT is the second door: one press from home to the nine tools on the job you hold. TODAY is the third: everything filed today, across the record. Then JOBS, MAP, THE JOB (the encounter, which nobody has to enter anymore), SETTINGS. Nothing was deleted — the game is all still there, it just stopped standing in front of the product.

And the machine opens up for content: a photo, a clip, an overhead or a walk now takes the WHOLE phone — the glass slides out of its shell and the shell fades back when you are done. That is Kymani's tablet idea, tied to what you are looking at rather than to a held finger.

First answer to that, and the easy half: stop making him choose a machine. The SLAB is the default now, because he has preferred it three times and the A/B was costing decisions instead of making them. The clamshell isn't deleted — it lives in Settings → MACHINE — it's just no longer a question anyone has to answer.

And the door wears the same device. Signing in through a clamshell and then opening a brick was two different machines inside ten seconds. Now the slab sits there POWERED OFF, whole, and the sign-in is printed on its own dark screen; the key says POWER ON, and pressing it boots the machine you were already looking at.

And the Dex entry got vastly simpler, as asked: GROUND and HOLDS are gone (neither told you anything you'd act on), and so is the cover photo — the name is the face here too, printed bigger, with the town and the day count on one line beneath it. What's left is what a job IS and what it OWES: name, town, days, address, what's on file, the next task in full, then the menu with its live counts.

Also checked the HISTORY key after last night's note — it opens the FILE correctly. That was my test harness clicking by text after the labels moved to aria-labels, not a regression in the machine.

And the night workers are workers now, not a page: THE CLERK (reads your day back) and THE ELECTRICAL CLERK (checks it against the code, cites the article and the frame) stand in the party under THE NIGHT, and A opens what they found on the job you're holding. The job's own page carries the same door as THE CLERKS. A there sends the electrical clerk through the last two weeks on demand — you don't have to wait for a night to see it.

Worse, the render hardcoded 1920x960 because I assumed every kept frame is a 2:1 equirect. The frames on record are 1024x1024 front/back views, and that filter stretched them into a funhouse. It now caps the width, keeps the aspect and never upscales, so it is right for either shape.

Worth knowing before the next shift: the shop box appears to be behind. A shift on Aug 28 produced the old square front/back views, but _tower_views was deleted on Aug 27 and only _tower_pano (one 2:1 equirect per pick) survives in the repo. Until the box pulls, shifts bank flat views instead of 360 stills.

Also: the code reader was blind, not quiet. Cord language sat in 12 captures on the Vitronics record, reached the line ASK reads 7 times and the line the CODE READER reads zero times - capLineDigest carried the note, a short subject and label text, and dropped materials and equipment, which is exactly where the eye files a cord. Those two fields are in the digest now, and the same read went from silence to two cited findings.

And the film is reachable. It was landing on the job row where nobody could see it; the shift results screen now carries THE FILM with its length and size, and one tap opens the share sheet. On a borrowed camera that is the whole trade: his card stays empty and he still walks off with the video of his own install.

Verified in a browser against a real legacy link, not just typechecked: the old single link becomes one named camera, adding a second keeps both with their own passwords, swapping back restores the first, and the mirrored keys follow. Sixteen unit tests cover migration, corrupt storage and duplicate SSIDs.

A finished shift now renders every frame it kept into one 360 timelapse and hands it back. It is nearly free - the frames were already on disk on their way to the reel, so it is one ffmpeg pass. Frame rate is picked so a 15-minute witness and a 4-hour watchman both come back about 30 seconds long instead of one being a blink. Lands on the job as film_url; SHOPBOX_SHIFT_FILM=off turns it off. The film never fails the shift.

And the code reader stopped citing from memory. The frame half of its citation law was real - a finding that cannot be shown gets dropped - but the article half was decorative: cite only had to be a non-empty string, so a number the model recalled survived. Now every lookup banks the articles the corpus actually handed back, and a finding may only cite what is in that bank. This will mean more silent nights. A wrong article number in front of an electrician costs more than saying nothing.

Known limit, stated plainly: this grounds the article (400) and not the subsection (.10 vs .12), because the corpus is Mike Holt captions and textbooks, not the text of NFPA 70. Subsection-accurate citation needs real code text.

The art is ours: generated from TB-001 as the reference so it is the same plastic under the same light, then measured and hole-punched in the repo the way the skin spec requires. Its grip rails were stretched once at build time onto a canvas taller than any phone, so the app never stretches the art at runtime and the corner bumpers keep their shape.

And the loud one. Kymani, twice now: "keep the keyboard hidden from users — never use the native keyboard. If you wanna type you MUST use an on-screen keyboard. Never break the experience." He was right and it had never been done. Nineteen fields across the machine and its sheets were summoning Android's grey slab up over the glass, which is the single biggest break in the illusion the product runs on.

So text is entered the way a Game Boy has always entered text: a character grid drawn on the screen itself, with the line you are writing above it. It answers to both hands the machine has — walk it with the D-pad and press A, or touch a letter directly in the tablet body. B cancels, DEL is a key, the first letter comes up capital and drops back. One grid, one implementation, two skins: the LCD's ink on the glass, the sheets' ink when a sheet asks for words.

Everything converted in one sweep: ASK on home and on a job, the new task, a task's words, a task edit, the day's gap answers, the day note, the part finder, photo notes, video notes and every timestamp mark, the space name, a new job's name, who the day is sent to, the address search, and the global ask bar. The only text fields left in the app are the sign-in and password forms and the X5 WiFi credentials — deliberately, because an on-glass keyboard there would break password managers, and those live outside the machine anyway.

The honest open question, and Kymani is the one who has to answer it: whether a character grid is tolerable for a real 200-character field note. If it is not, the answer is voice, not a better grid.

So PLAY opens ON the lenses. Above them, always, is the job the shot will file to: name, level, what's owed, where you stand, and the swap that says the cartridge can change. Under the nine lenses ride the three plays that are not a lens — ASK, SHADOW, SET TASK — so one cursor reaches everything this job can be done to, and nothing is hidden behind a verb. Twelve rows, one press each.

The charm stays where charm belongs: on the operator and his companion (they stand beside the job now instead of across an empty field from it), on the beats, on the burst when a shot lands. What left was the floor between them, the four-verb command window, and a press that did nothing but open a menu.

"Make the shoot page more user friendly and SIMPLE — just tool name and ability, like object tracking, query record for 360 video, 3d model for photos." The lens page was a paragraph of numbered steps; a lens looked like homework. Now it is what it IS in one line, then what it CAN DO as its own rows: 360 WALK — the X5 takes the whole site in one pass · QUERY THE RECORD, lands on the exact second · STAND ANYWHERE · TRACK AN OBJECT, soon. An ability that isn't built says soon in its own words; nothing here promises what the record can't keep.

"Lessen the height of the device so phone navigation bars don't show on the device — like a nice healthy black bar." Installed on Android the nav bar is drawn OVER the page and the platform reports no safe-area inset, so the machine's foot slid under the three buttons. When the app stands alone and the platform admits nothing, one nav bar's height is reserved as the frame's own black ground — and the glass takes the lion's share of what's left, so the screen doesn't pay for the band. In a browser tab the measurement stands and nothing is reserved, which keeps his older law (no dead black at the bottom) true where it applies.

A PICTURE HANGS IN A FRAME (Kymani: "let me view photos in the glass frame, not full frame as forced"). The viewer is a window ON the glass now — his frame, the machine's ground around it — never edge to edge.

ONE KEY FOR DAYS. The ▼ shots walk came off the map: the day's shots are drawn on its line, and A opens the day's own file, which is where you read them. ◀ ▶ days, A opens, B out.

THE FRAME FOLLOWS THE DAY. With a day picked, the still is framed on that day's own captures, not the whole job — so walking the strip walks the ground: one day is the corner of Rockville Pike, the next is the yard two miles north. A day's work that stands in one spot gets a lot-width floor instead of a mile, so days stop looking identical. With no day picked it's still the whole job.

NO WAIT. The map keeps showing the ground it has until the next one has decoded — never a blank — and the days either side are fetched while you read this one, through the same framing math and the same box, so the bytes you press into are already decoded. Measured: pressing ◀ makes no new request and swaps in 17 ms. The last eight frames are held in memory for the session; nothing is written anywhere, and the still itself is a five-minute private browser cache, never our storage.

Also moved our scale bar off the bottom edge — Google's attribution owns that line and may never be covered.

The RECORD field was weird because it was a meter that needed a legend nobody has (▮▮▯▯ 2/4). It says words now: HOLDS · PHOTO · WALK — or NOTHING YET, or ALL FOUR KINDS when the entry is complete.

Tasks read in full: the entry's task line used to cut at one ellipsis and the list ran off the bottom of the frame. GROUND and DAYS fold into one row to buy the space back, the next task's words wrap across two lines where you can actually read them, and everything else defers to the board — which was already a menu item and now carries its count, exactly the fallback he proposed.

And a real bug behind 'in the Dex file pages I don't see all the content jobs have'. The record was hydrating from a TODAY-ONLY cache — and because that made it non-null, every `if (ledger === null) load it` guard in the app concluded the record was already in hand and skipped the real fetch. So a job's FILE showed only what you shot today, forever, and the Dex entry read '0 on file' for a job with hundreds of captures. Three fixes: the whole record is cached and painted instantly, a `ledgerFull` flag says whether what we hold is the truth (every load guard now asks THAT), and the old 2000-row client cap is gone — it was silently dropping whole jobs off the bottom of a long record.

Rapid, too: the record starts reading the moment the machine boots, so the Dex, the entry and the album are already full by the time you walk there. The cache steps itself down (3000 rows, then 1200, then 400) until it fits the browser's storage quota, so the instant paint survives exactly the heavy accounts that need it most.

Two screens stopped lying while they wait: an album that is still reading says so instead of claiming the job is empty, and a Dex entry never counts below the job's own totals.

Second: the tool list was missing tools. True — it carried six hand-picked ones. The armory now carries the lens dial's own NINE, in the dial's own order: PHOTO, VIDEO, 360 WALK, PANEL, PART, SPLAT, UPLOAD, NOTE, MEASURE — one roster, and one iconography: the same licensed item icons the dial wears, not hand-drawn stand-ins. PANEL and PART fire their real flows, and SPLAT got its own door (the orbit recorder with KEEP-sends-to-the-box), which it never had outside the dial.

SECOND, THE GLASS IS SMALL AND REAL ESTATE IS GOLD: the Dex entry page was overlapping itself — LOAD JOB printing over the stat rows, the address over TASKS — because its content spilled out of an unclipped frame into the menu below. The frame clips now, the identity block tightened, and the five options fold into a Gen-I two-column menu (a third of the glass back). Dex rows tightened too: NEW JOB can't wrap around its hint anymore, and the nearest-job chip says just the distance — the footer already says the rest.

THIRD, THE MAP'S DEAD END: a job whose walks carry no GPS had a struck-through 'no days here yet' and the A key did nothing — the whole screen read broken. A always goes into the job now; no trail just means no trail.

AND THE FOOTAGE PLAYER LEARNED IT LIVES IN A MACHINE: inside the glass it wore full-phone chrome — the answer card was sized in dvh, the PHONE's viewport, so one ask swallowed the whole screen. The ask measures against the player now, the type goes dense, and every overlay (status pill, SAVE, play button, hop chips, transport, mini-map) scales to the small glass instead of colliding.

Then the finishing pass he asked for while he hit the gym. THE BOOT CEREMONY: every open, the TRADES BOY wordmark falls from behind the bezel, lands dead center with a two-note ding (silent when the browser hasn't been touched yet — the fall carries it alone), TRADESMAN SOFTWARE signs beneath it, and the power LED ignites the moment the software lands, then breathes. Tap skips it.

THE BACKLIGHT: the glass was reading like paper taped over a hole. A whisper of top sheen and the glass edges darkening into the bezel now seat it as a lit panel inside a machine — pure overlay, content untouched.

Small truths: the Build row reads the machine's own model (TB-101 / TB-001), and CLAUDE.md now carries the whole console-era architecture so no future session has to rediscover it.

The machine's foot now stops ABOVE the phone's own navigation bar — both doors probe env(safe-area-inset-bottom) and keep that strip as dark ground, so the pak's grip ridges never hide under the system buttons.

The 'weird' hinge was the stretch band's fault: it lived in the strip right under the barrel and smeared the barrel's shadow into a long soft gully. The band moved to the lower deck — the flat shell between the speaker and the pill keys — where stretching is invisible and reads like a classic handheld's chin. The hinge junction shows the art as painted again.

And the close: the fold was rotating LIVE PAPER in 3D while a dim plate stayed frozen flat over it — two wrongnesses at once. Now the dim plate is part of the folding lid itself and the backlight dies fast (fully black by a quarter of the hold), so what swings shut is a dark shell. Power off, then the lid — the order a real machine dies in.

The fix is the brick's own trick brought home: the SP's deck grew a GAP — the featureless shell band right under the hinge barrel (measured plain, rows 1262-1333) that stretches invisibly. Surplus height now feeds the SHORTER fold arm first (glass on the lid side, the gap on the pad side), then splits evenly — so the lid arm and pad arm stay exactly equal while the machine grows to the phone's full height. Measured on device: all four folding pieces hinge at exactly half the viewport. The hinge is the machine's waist.

Result: no black band anywhere, a taller pad with the controls pushed toward the thumbs, a bigger glass than the parity build had, and the pak still hanging out of the bottom edge. One geometry serves both machines now — the gap is just a def entry.

The A/B stands: Settings → Machine flips TB-101 clamshell / TB-001 brick with one press, and nothing else will churn under him until he rules.

Two changes. First, the controls grew: the d-pad is 38% larger and the A/B pair 35% larger — done deterministically in Pillow (circular patch scale-up with feathered edges) after a Gemini edit pass came back with leathery texture drift; the art's material stayed exactly ours. Touch zones re-measured to match.

Second, the deck grew a GAP: a featureless band of plain shell between the screen panel and the controls that stretches to absorb the phone's surplus height — invisible, because there's nothing in it to distort. The glass now takes only a measured share (about half the surplus, capped), so the screen reads like a real handheld display, the full menu still fits, and the controls land at the bottom where thumbs actually rest.

The first cut overshot — the screen clipped SETTINGS off the menu and the midriff went barren — so the split was rebalanced until the menu breathed and the blank shell read like the logo zone on a classic brick rather than a void.

And the Settings list had outgrown the SP's glass with no way to scroll — the new rows this session (Feedback, Machine, Power, the box switches) clipped off the bottom and the cursor walked into the void. The list scrolls now, and the cursor DRAGS the view: every listRow list keeps the selected row inside the glass (scrollIntoView on selection), so ▾ always shows you where you are.

Third: he looked at the SP's hinge and called it — 'not physically possible, it's not connected the correct way.' The barrel floated between the halves like a loose tube. One constrained Gemini edit rebuilt the junction (the lid's side wall now molds down into its knuckle, the deck rises into the barrel, interlocking on one axis) and ONLY that strip was feather-composited back into the shipped skin — every measured control and the screen hole stayed bit-identical.

So the shell became a SkinDef — two machines on one rig. TB-101 is the SP clamshell exactly as built (fold-to-sign-out, GAME PAK, closed-lid door). TB-001 is the new BRICK: our own generated art in the same graphite and sienna, full-bleed (the device's edges ARE the phone's edges), a glass nearly twice the SP's, d-pad, A/B, two pill keys wearing the cog and clock, the sun key, speaker grille. Same hotspot rig, same brand plate, same LED, same blip.

Neither machine was deleted: ?skin=brick and ?skin=sp flip between them (it remembers). The founder holds both and rules; the loser dies by his word, not ours.

The brick has no lid to fold shut, so Settings grew a POWER row — sign out, on both machines. The box switches moved down two rows.

The GAME PAK is now real: a GBA cart is 58.5mm against the 84.6mm body — 0.69 of the width, protruding about a centimeter. We generated a proper pak (graphite matching the shell, ridge grip, blank cream label), and it tucks under the deck with only its lip out, grip at the phone's bottom edge, the held job's name printed live on the label sliver. Tapping it still opens PLAY.

THE FOLD IS TRUE: the lid rotates about the hinge line, which sits 230px into the deck band — so what must match is the ARMS, hinge-to-lid-top versus hinge-to-pak-end. The glass grows only until those arms are equal, the pak's lip is capped at a real protrusion, and any height left over is dark ground ABOVE the machine — the deck stays seated on the bottom, at your thumbs, and a closing lid lands flush on the machine's foot instead of sweeping past it.

Side effect Kymani asked for: the closed machine on the sign-in door now sits on the bottom half of the screen with the words in the dark above it.

And the pak answers the bigger question — should jobsites BE cartridges? They already are: the holding law slides a job's pak in when you arrive on its ground, and a deliberate swap sticks. So no rewiring — the pak just SHOWS it now: when the held job changes, the cartridge visibly re-seats, sliding up into the slot with the new job's name.

EQUAL HALVES: the glass bonus is capped hard now — the lid reads as the deck's twin square, the way the SP truly is; the surplus height feeds the cartridge instead (widened toward true GAME PAK proportion while we were in there).

One bug caught on the way: the door's text block used transform centering, and the entrance animation's final frame (transform: none) stripped it — margin-centered now, with a comment so nobody re-learns it.

TRUE PROPORTIONS: the bands never stretch anymore — square lid, square deck, the AGS-101's actual shape. The glass grows a bounded amount, and everything left at the bottom belongs to THE CARTRIDGE — his call: inserted in the bottom slot, grip ridges, a cream GAME PAK label wearing the loaded job's name, running off the screen edge into your hand. Tapping it opens PLAY: the cartridge is the job, now literally.

THE LID FLIPS: hold-to-close is a real hinge rotation now — the whole upper half (lid band, bezel columns, glass) rotates about the hinge line in perspective, dimming as it turns, spring-back on release. Verified mid-hold at rotateX(-36deg) with all four elements turning together.

SILKSCREEN ICONS: the SETTINGS and HISTORY words became a cog and a clock, stroke-drawn at silkscreen scale; the LIGHT word is gone — the painted sun was always enough.

ONE DOOR: the closed machine is the only landing. LOG IN and CREATE ACCOUNT open their forms right there above the machine — same proven auth calls as /login (full_name trigger, confirmation-email path), submit button reads OPEN THE LID, and the auth provider hears the session and opens the machine itself. The paper login page never appears in the flow.

Engineering note: the fold runs on imperative refs (one transform, one opacity, per frame) so holding never re-renders the pad. If sign-out cannot unmount the machine (demo, offline), the lid springs back after a beat rather than stranding a closed shell.

FRAMING: a tall screen's surplus no longer all floods the glass — the lid absorbs a share (flat plastic stretches invisibly) and the deck a sliver, so the machine keeps SP proportions on every phone instead of becoming one giant screen with a sliver of deck.

THE LID CLOSES: tap the hinge and the machine folds shut — signs out and lands on the closed-lid door. Logging out IS closing the lid; opening it is logging in. The circle is complete.

THE DECK NAMES ITS KEYS: SETTINGS and HISTORY silkscreened under the bottom buttons, LIGHT under the sun button — which is now the WORK LIGHT (the real flashlight, lit amber on the silkscreen when on). The faceplate flip lives in Settings where it always was.

THE SLAB IS GONE: 256 lines of masthead, moulded keys, dish and grill deleted. Everything it owned was rehomed first — dark flip = Settings row 1, quiet = the new FEEDBACK row (replacing the Shell toggle, which died with the slab), torch = the sun button, every key = a painted hotspot. If the skin image ever cannot paint, the glass takes the whole viewport bare — emergency glass, never resurrected chrome.

And the shell stopped being a URL trick: SETTINGS grew a SHELL row — TB-101 / classic slab — pressed with A like everything else, remembered like everything else. Verified live on /tradesboy: the row toggles the whole machine mid-session without losing your place.

The kit grew skinOn and toggleShell (type regenerated by the tool, per the split law).

Legendhood pass, all small, all hardware soul: the BACKLIGHT BLOOM — every cold open, the glass wakes dark and blooms on over a second, the AGS-101 story told at boot; the POWER LED — a breathing green light on the deck's right edge, because a machine that is on says so; the phone's own status bar now paints the skin's ground color so the chrome joins the machine; and the button press shadow tightened to read as key travel instead of a smudge.

Verified at 22:9 before pushing. The machine now fits every screen, shows the whole day on the glass, wears the name in the right place, and breathes.

The compositing padding above and below the device is cropped at render, so the machine runs edge to edge with no dead bands and every reclaimed pixel goes to the glass. Wide screens flip to height-driven scale and letterbox the sides. Geometry moved to image-pixel truth in pad/skin.ts (SKIN_PX, spots in source pixels), measured off skins/tb101.png.

Verified at 22:9 and 19.5:9 before pushing: full-bleed both, seamless bezel stretch, painted d-pad still driving the real cursor, wordmark on the bezel.

The pipeline finished it in-repo: composited to 1080x2400, screen hole punched to transparency at the measured rect, control anchors measured off the actual paint and written into SKIN_SPOTS. Shipped at public/skins/tb101.png and made the DEFAULT shell — a fresh open of the pad is the TB-101, with TRADESMAN · TRADES BOY (TM) printed on the bezel by the brand plate (transparent type straight on our own paint; #brand on the default URL). ?skin=off still remembers the classic slab.

Verified live on /tradesboy before pushing: the real menu inside the machine, the painted d-pad moving the real cursor, the wordmark on the bezel. The night's whole arc closed: cartoonish CSS to design canvas to illustrated SVG to the emulator-overlay architecture to art that is finally ours.

What shipped: the plate itself — TRADESMAN · TRADES BOY (TM) in the masthead's own Barlow, positioned on the skin's bezel strip as live DOM (SKIN_BRAND in pad/skin.ts), rendered only for opted-in skins. The placeholder stays opt-in via ?skin= and keeps its own face; ?skin=off now remembers the classic shell properly.

The day the real TB-101 skin lands (SKIN_SPEC.md is the brief, and it now documents the dormant plate), the full branded default experience is one URL with #brand on the end — the code is already waiting for it.

The machine also got its voice: one Game Boy square-wave click per key press, synthesized in pad/skin.ts, riding the same buzz() as the haptic so the pad's existing QUIET switch governs both, on both shells.

Verified on the /tradesboy demo before pushing: classic boots unchanged, skin mode boots the real menu inside the shell, the painted d-pad moves the real cursor. Known squeeze, on the record: the skin's glass is landscape 3:2, about half the classic height, so tall screens clip their lower rows until they learn the short glass.

The skin stays config, never repo content — the dev placeholder is the unlicensed RetroArch overlay and ships nowhere. The day our own TB-101 art exists (docs/tb101/SKIN_SPEC.md is the brief), it is a URL paste away from being the product.

Inside a day, ▼ walks the ticks forward through time and ▲ back; the caption names the one under the cursor — PHOTO · 9:00 AM · 3 of 8 — with its note beside it, said plainly as 'no note' when there is none. A opens that exact capture. B steps off the tick, then out of the day.

On the region view a job's mark is now weighted by its DAYS WITH DATA, not its photo count.

The ground only suggests. Arriving on a job's ground auto-holds it (his 08-27 law, kept). A swap you make on purpose sticks until you leave. Standing on a different job than the one you hold prints one line — AT WATTZLED · HOLDING ▸ — and A flips. Somewhere no job claims prints SOMEWHERE NEW · 3.2 MI OFF · NEW JOB ▸ and A starts one. The 'wild ground' encounter from two days ago is retired: the plate is always the job you hold, the ? is reserved for holding nothing at all.

One ruler, finally. The pad measured to a job's front door while the engine room measured to its whole ground (the address plus a mile around every worked spot — lib/geo's distToTerritory). Standing on a corridor you'd worked, the engine room said HERE and the pad said wild. The pad walks the same fence now.

Pokémon's rule, now the pad's: what appears is what's in the grass under your boots. On claimed ground, that job appears. On wild ground, WILD GROUND is the encounter — its own plate (L?, NO JOB CLAIMS THIS SPOT, NEAREST · <job> · <miles>), its own beat, and pressing the plate or the ? starts a NEW JOB there. The job you loaded is what you're HOLDING — the strip says so by name — and the menu still acts on it (ASK, SET TASK), because you can read a job from anywhere; you just can't face it from there.

The ? was unreadable for two reasons. The sprite sheet is 32-pixel cells, 16 across, two rows — a spinning ? over a pulsing ! — and the build cut it as 64-pixel cells, so every marker was a 2x2 of both glyphs at once. And a quiet job wore a ? over its head too. Now the ? means one thing: unclaimed ground. A job with tasks wears the !, a job with none wears nothing.

Insta360's MediaSDK refuses a plain mp4 — it needs the .insv metadata — so the relay lane stitches with ffmpeg's dual-fisheye remap at the lens FOV the tower already measured on this very stream (190). A relay frame is exactly 2:1, a phone clip never is: that is the detector, with --dfisheye / --flat as the override. The row now says projection=equirect instead of pinhole.

All nine live walks still on the box were re-stitched in place — same URLs, the phone just plays the new file. Not seamless the way an uploaded .insv now is (that path has the camera's own optical-flow stitcher); continuous, no pinch, no black bar.

Kymani already holds an Insta360 developer license (X5 registered). The Windows MediaSDK 3.1.5 is on the box now (D:\splat\insta360-sdk) and its stitcher does optical-flow seams plus FlowState levelling on the 3070 Ti. Same frame, same walk: the helmet is whole, the seam is invisible, and the horizon is level — the footage stands upright instead of on its side. A 2-minute walk stitches in 88 s at 2304×1152, 6 Mbps, moov in front so the phone starts playing in seconds.

preview360.py now uses the SDK whenever its exe is on the box (SHOPBOX_STITCH=v360 goes back; any SDK failure falls back to the ffmpeg recipe on its own). Only .insv uploads go through it — relay walks stream from the camera already stitched. --no-upload lets an operator stitch a file by hand without touching a job.

What the seam actually is, per the measurements: a ~1-degree ROTATION between the two lens frames (±12px vertical shift, opposite signs at the two seams) that v360's dfisheye mode has no knob for, plus near-field PARALLAX (the operator's helmet halved) that no static remap can bridge — Insta360's own stitcher runs optical flow for exactly this. The fix is a named post-demo project: split-lens remap with a measured per-lens roll, and an optical-flow blend (MediaSDK evaluation beside it). Field mitigation until then: stick high, seam off the subject.

And YOU SAID is deleted from the wrap (Kymani: 'the you said section is cancer') — the day's close is not a nag list. The promise plumbing survives for other surfaces; only the wrap rows died.

The default flips to ON: a default must never disable the product. An operator who wants the eye off says SHOPBOX_INDEX=off out loud. The box's .env now also sets it explicitly; older walks get their frames by hand-run backfills; the index-ahead claim-stamp behavior when the gate is off (it marks jobs claimed forever) goes on the post-demo worker list with the atomic job claim.

And footage opens INSIDE the machine: A on a walk tile (and SEE THE PROOF under an answer) paints Watch360 in the glass — A plays and pauses, the ◂ ▸ dial seeks five seconds, B closes the layer and the pad is exactly where you left it. Driven through the video element itself so the player's own state stays honest. /watch stays alive for deep links and shares; the twin at /points still navigates — it is its own place.

Both were asked for three times this weekend; they shipped once the rehearsal spine was proven, and rehearsal run #2 is their proving ground.

True to Nintendo (Kymani, mid-build): a photoreal still under pixel marks breaks the glass. So on the map the bird's-eye goes through the LCD's four-tone filter — the GB Camera's answer to a photograph — and the raw photo stays where photos live: the viewer, via ▲ LOOK DOWN.

The fix is one Postgres function, merge_recon_stats (stats = stats || patch, under the row lock), and every writer now sends only its own keys through it — worker.py's patch_stats, phone_preview.py, preview360.py, and the webhook route (with a patch-aware normalizer so the old merged-view guards don't backfill pinhole onto good rows). Legacy read-merge stays as fallback everywhere until the migration is applied.

Run the new migration (supabase/migrations/20260830_merge_recon_stats.sql) in the Supabase SQL editor to switch the atomic path on.

The record-line for a walk frame now says (frame 7) — t+32s into the walk, in both ASK and REPORT, so a cited frame is an address, not just a picture.

"The ask button in the Insta360 video only loads after the video ends." It lived on the pause — pause-to-ask — but nothing said so, and a walk watched straight through never showed it. An ASK button now sits in the playback row while the footage plays; it pauses on that exact second and the bar comes up.

On the job's map the picked day's captures stand on the still — every shot of that day, where it was taken — so choosing a day shows you the day. The day dots and the compass and scale wear a paper halo so they read on the dark four-tone ground (they'd gone invisible). And the still requests half the pixels: it goes through four tones anyway, so 2× bought nothing but seconds.

THE WHOLE JOB. The job's own map framed the day centroids, not the captures — so points at the edges fell off. It frames every capture point on the job now, plus the door and any placed task, with room to breathe.

TASKS ON THE MAP (Kymani: "your call — bane or boon?"): boon, kept small. An open task with a place is one small orange diamond on the job's own map, nothing more — no labels, no rows. The region map stays clean.

Not built: an address search. It's a new surface, and it'd be a worse Google Maps — what you want when you type an address is before it's a job.

And every job gets the same map (Kymani: "some open a viewer, some move the frame around — it'd be better to just hover a site, press A, go into its own map whether it has days or not"): A on any job cuts the frame to that job's own ground — its trail when it has one, its door alone when it doesn't — with the same keys and the same foot line. A job with no days says so plainly and A opens its file.

So: KEEP THIS — a second switch on the note sheet. A kept note is pinned on the job's Dex entry under KEEPS, oldest first — the job's own rulebook; A opens one big. The FILE album has a KEEPS kind for every keep on every job. And the AI knows them: ASK already reads every note; the shadow now gets the keeps in its context word-for-word and is told to quote them when they apply; the night clerk reads the same rows.

One row, one flag (`keep` on a daynote). No new table, no new screen.

DELETE on the task page: two presses — A arms it (the foot says A AGAIN — GONE FOR GOOD · B KEEPS IT), A again deletes and walks back to the board. B disarms.

And the field measures itself now: the operator, the shadow and the stand scale to the glass that's left (128px on a tall one, 48px on a short one), the command window gives up two lines of copy on a short glass, and below 64px the YOU plate steps off the field entirely — the closet is in SETTINGS too. Nothing on PLAY can overlap the window again on any phone.

HOT. Kymani: "let me mark a task late so I know it's a hot item." A task has a HOT switch on its page (◂ ▸); hot tasks wear the red slime, a HOT tag on the board and the entry, and sort first.

THE TASK PAGE, REDRAWN in the machine's grammar: one cursor, a label on the left, the value on the right, ◂ ▸ only on rows that turn, and what A does said ONCE at the foot for the row under the cursor — nothing printed per row that the foot can say. Rows: WORDS · DAY · WHERE · PHOTOS · HOT · DONE · PROVE.

A 360 walk in THE FILE could sit completely silent under A — a relay walk has no video_url until the box stitches it, so the tile had no door, no image, no words. Now a doorless walk says WHY (still stitching, or failed) instead of eating the press.

A sent walk refreshes the ledger itself — no HISTORY press owed. Why now: the record answering with proof IS the demo, and nothing off that spine was touched.

And his design lands with it: off every claimed ground, the enemy half becomes WILD GROUND — a wild ??? standing where the site's face would be, 'A NEW JOB CATCHES IT'. Press it and the create form rises. The encounter that changes is the map living inside the fight.

The target select starts on THE JOB · just shooting now (he: "it should start off on the job, just adding to the raw job") — a task is one ▾ away, never the default.

And the board reads like it should: full task titles wrap to two lines instead of truncating ("I can't even read the full title"), and every task wears a CIRCLE on its right — tap the circle, it ticks; tap the words, it opens. The slimes stay ("the slimes are cool though").

Verified on the pad: titles wrap (measured 2 lines), the circle ticks and reopens, the select opens cursor-on-THE-JOB. The presence pieces (enemy following your feet, WILD GROUND) need a walk with GPS on — the demo has no location.

The PHILOSOPHY: affirmed and written down — a day is the phone's local midnight to midnight, everywhere, one knife (todayStr): the board's today, SEND THE DAY, the trail's days, tomorrow's plan. Never a second day boundary.

The COUNTDOWN TIMER: waste, and now it's illegal. In Animal Crossing the reset gates content, so the clock earns its place; here midnight gates nothing a tradesman can act on, so a timer to it is chrome by definition.

What shipped instead is the version that's TRUE: the machine's clock, the way Gold/Silver printed the time on its menu — FRI, AUG 28 · 2:36 PM, one quiet line — and the one deadline that is real on a jobsite: in the last 90 minutes of light on the ground you're standing on (measured, lib/sun.ts), it says '42 MIN OF LIGHT'; after dark, a quiet DARK. Verified on the pad.

And the concrete one: "the camera flipper is overlaying the items count." The dial's N/9 counter sat in the top-right corner the flip button owns; it lives on the LEFT now.

Still open, said honestly in the reply: the deeper 'is the task system just a calendar' worry and the task-data repetition across the plate/strip/select — that's a design conversation, not a patch.

One system now. Press ATTACK on a job with open tasks and the message window asks ATTACK WHICH? — Gen-I picks a move, we pick what the shot is FOR. The open tasks stand as rows wearing their own slimes, THE JOB · just shooting is the free-shot row, and the cursor defaults to the most urgent task. A shot at a task IS its proof: the lens opens targeted, the landing shot closes the task and pops its slime. The field steps out while the select holds the glass (the ask line's own law). B closes; ▴▾ walk the targets; every other verb closes the select.

With nothing owed, ATTACK goes straight to the lens exactly as before — zero friction added to the free shot (the lens-gate law holds). Under the hood: a fireAt(target) verb in the kit (type regenerated), targetSel state, and the D-pad guard sits at the TOP of the handler because the generic ▴▾ narrowing had swallowed it below. Verified on the pad end to end: add task → ATTACK → ATTACK WHICH? → B closes → free shot path clean.

THE SHAPE. pad/base.ts holds the shared types and constants (PlayerSite, PLATES, the Silkscreen face, GLASS_TRADES). pad/screens/<name>.tsx holds each screen — the if (screen === …) blocks of glass(), moved VERBATIM, each a function taking the KIT. pad/kit.ts is the kit's type, GENERATED by the compiler (tools/pad-kit-type.mjs) from the literal in RealityPlayer, so a screen can only reach for what the pad actually hands it and tsc holds every screen to it. glass() is now a dispatcher over SCREEN_PAINTERS in the old order.

HOW IT WAS CUT. tools/pad-split.py did the move mechanically — block text untouched, dependencies destructured from the kit at the top of each file, glass-level helpers (numOf, dexCur) hoisted to component scope. It paid for itself the same hour: the other session landed the TOOLS-screen deletion on main mid-split, and the split simply re-ran on the new file.

VERIFIED: tsc clean; next build; the demo pad at /tradesboy walked on localhost — menu, PLAY (with the beat), taskboard, Dex, entry — painting through the split, zero console errors. Input handling (A/B/D-pad) stayed in RealityPlayer; moving it beside each screen is the next slice, not this one.

One resident was carried out before the demolition: the dusk field move. It's a TRIGGER (his own law — a feature nothing reminds you of doesn't exist), so it now lives on PLAY itself: when the light starts going on the loaded job's measured ground (lib/sun.ts) and no worker is on the clock, the field offers 'Getting dark here. Leave the watchman on it?' — the way Pokémon offers CUT at the tree, where you're standing.

Verified on the pad: boot, PLAY (plate, trail chip, tasks strip), map tap → Dex entry. tsc + build clean.

The one violation found, fixed: on the map, the A key opened the job's Dex entry while tapping 'enter' opened the old TOOLS grid — same gesture, two destinations. The tap mirrors A now.

Everything else holds: the Dex list carries only NEW JOB (creation is the list's own act); every PLAY door pivots on the loaded job; the entry pivots to every axis (LOAD/FILE/SHARE/TRAIL); SEND's site list is a lawful picker; B retraces everywhere via the trail.

FLAGGED, decision pending: the 'site' TOOLS screen now has no door at all. It duplicates ATTACK's question — but three unique things live only there: the dusk 'leave the watchman on it?' field-move, the files drawer, and splat-an-existing-clip. They need lawful homes before that screen is deleted. Kymani's call, noted in DESIGN.md.

He also asked the structural question: "should we add map and play to the Dex? but then every list is just a menu of the other ones rearranged." The answer that keeps the machine coherent: each screen answers ONE question (DEX = which jobs; the ENTRY = what a job is; MAP = where and when; FILE = what happened; PLAY = now; the board = what's owed), and doors only PIVOT on the object under your cursor — Gen-I's own grammar (the Pokédex's AREA button is exactly a dex→map pivot). The Dex LIST gets no new doors; its ENTRY already pivots to every axis (LOAD = now, FILE, SHARE, TRAIL). Cross-doors on lists is what makes menus feel rearranged; pivots on the held object is what makes a Pokédex feel whole.

Also fixed underneath: the key handler's dependency list was missing town and trailIx, so A on the map acted on a stale cursor — the exact class of stale-closure bug CLAUDE.md warns about. Both added.

THE TRAIL derives from data the record already holds — every capture's pin carries a timestamp — so it costs the user NOTHING, ever. A job's pins group into worked days; each day is a dot on the region map, newest darkest, fading toward the first day, a dashed walk joining them.

ON THE MAP: ◂▸ still walks the region; ▴▾ now walks the DAYS — ▾ steps a day back along the trail (the picked day wears the orange ring, the caption names it: 'SUN, AUG 23 · 1 capture · day 3 of 5'), ▴ walks home to today. And stepping off today CUTS THE MAP IN to the job's own ground (the frame rebuilds from the trail, scale bar drops from miles to feet) so you literally retrace the walk — then cuts back out to the region at today. Gen-I hard cut, no loading, all drawn.

ON PLAY: the plate wears a TRAIL chip — three fading footstep dots and 'TRAIL · N DAYS ▸' — press it and the map opens standing on this job. ON THE DEX: a TRAIL row joins LOAD JOB / OPEN FILE / SHARE. One feature, three doors, zero new input.

Verified end to end on the pad: map dots + time-walk + zoom-cut (scale 5 mi → 2640 ft), the PLAY chip, the Dex row. The demo (/tradesboy) now carries real ground and a five-day trail on Redland so strangers see it too.

THE STANCE: the base sprite art faces left, and only the walk animation was flipped — so at rest the tradesman stood with his back to the fight. He (and his shadow) face the enemy always now, the Gen-I back-sprite stance.

ONE TRUTH: the plate read st.owed from the sites index (stale) while the strip counted the live task list — 0 vs 4 on the same screen. The plate, the CLR bar, the enemy's ! marker and the TASKS strip all read the SAME live list now; the index only stands in before the first task fetch, on every one of them equally.

ONE ENEMY: the wild pack drew up to three slimes at the site's feet. It's one slime now — the most urgent (dated first, late wears red) — with a small ×N beside it. A landed proof still pops it.

THE DAY DIAL IS EVERY DAY. It was a four-stop ring (none, today, tomorrow, next week). ◂ ▸ now step one day, A jumps a week, stepping back past today lands on NO DAY. Any date is a few presses away and a late task can be walked back to the day it was really due. Days print the way a person says them: TODAY, TOMORROW · 8/29, MON 9/6, LATE · FRI 8/22.

LONG WORDS WRAP. The task's title and its WORDS row broke off the glass on one line; both wrap like paper now, up to four lines. Every other row keeps its one-line ellipsis. Not yet seen on the phone — if a line still runs off, pair the phone and it is one style fix.

THE LANDING. When a fresh row tops the ledger, its KIND lands on the job in his projectile art: a clip streaks, a 360 walk circles, a panel read crackles, a part sparks, a photo bursts. Only rows younger than two minutes fire, so a cold load never replays the whole day.

THE DEX HAS MOODS. A job not worked in a week wears his sleepy bubble in the list; one never worked wears a ?. THE READER sits beside READING THE RECORD… while ASK thinks. His resource counter frames the taskboard's tally, and his toggle draws every DONE and the faceplate switch.

Also: the deploy that failed was an earlier one — prod is serving the newest commit, and a clean full build of main passes.

THE NIGHT READ (/api/cron/night-read, 12:20 AM ET). For every job that saw work today, Sonnet reads the last ten days with the job's MEMORY PAGE open in the real memory tool (memory_20250818): a standing page of notes the record keeps about that job, updated with the tool's own verbs, stored beside the job (kind=brief, scope=memory). Then it files ONE finding — what changed, what is owed, what looks wrong, every sentence carrying its [C#] marker — stored as scope=night. The pad loads it as the day's read the next time that job is loaded (no button, no wait) and the scribe says THE RECORD READ ITSELF LAST NIGHT once. Silence is a valid finding.

ASK READS THE MEMORY. Scoped to a job, the corpus opens with THE RECORD'S STANDING NOTES — context, never evidence; a claim still needs its capture marker. The record also stops reading its own brief rows.

THE OVERNIGHT INDEX. /api/sites/index gained batch/collect modes: every pending read is submitted to the Message Batches API at HALF PRICE, rows are stamped index_batch so the live pass leaves them alone, and answers are written back through the same applyRead. The night cron submits and collects. A big card or an INDEX_V bump now costs half and nobody presses anything. readParams is the ONE builder of the read request — live and batch cannot drift.

STRICT EVERYWHERE. Every tool the app answers through (ask, part, panel, report, scout ×2, day-draft, shift debrief, the night finding, the shopbox frame reader) is strict: the API validates the JSON against the schema before it reaches us. INDEX, promises and the X5 screen reader moved from "return strict JSON, no fences" prose-parsing to output_config structured outputs — brace-hunting is gone.

ONE HOUR OF CACHE. ASK's corpus was cached for five minutes; a tradesman asks, walks fifty feet, asks again twenty minutes later and paid full price to re-read the card. Now ttl 1h (measured: 9,033-token write, then a 9,033-token read at a tenth the price).

THE PART FINDER CHECKS THE WEB. Its wall was always stock nobody publishes; the one thing the web CAN settle is whether the part the eye read exists under that name. Up to two server-side searches (web_search_20260209, /usr/bin/bash.01 each), a CONFIRMED line, and the pages it read printed as source links. The photograph still rules.

NOT DONE, honestly: API citations do not fit ASK — its answer travels inside a streamed tool call and citations only land on text blocks; the [C#] marker scheme already does that job. structuring-prompt.ts was left non-strict (many optional fields, tested, DO NOT BREAK). The night read has not yet run on a real night — first firing is tonight; check /api/cron/night-read's log tomorrow.

VERIFIED: tsc clean; 18 live API checks (every strict schema incl. the streamed ask tool, both index schemas on Haiku, web search + strict tool, memory tool loop, 1h cache, batch create) all pass.

THE TRADES. The default look is an electrician now, not a miner. The closet's first row is TRADE: ELECTRICIAN, PLUMBER, CARPENTER, LABORER, GROUNDS, MINER, SUPER, INSPECTOR — one-tap loadouts from his packs, and the rest of the closet still takes it from there. A custom look reads CUSTOM.

THE STAND. You and your shadow share one stand: the shadow a step behind, a little lower, facing the other way — the way a shadow falls. Walking (the job not under your boots yet) faces away from the stand.

THE ARRIVAL. Loading a job is the wild encounter: the glass wipes to black in seven steps, the job slides onto its stand from the right, and the Town Crier rings it in — A wild SHADY GROVE appeared! If the job has a late task, the Wounded Knight says so instead.

HIS WHOLE SHEET, IN CONTEXT. The operator's animation is a state of the world now, not a decoration: attack when you shoot, jump on an arrival or a level, cheer on a proof, RUN while a task here is late, WALK while the job isn't under your boots yet, and lie down when the day is done here.

THE SPEAKERS. Every beat has a face beside its words, cast from his characters pack — the crier for a wild job, the scribe when a job is fully recorded (the job bows off its stand while he writes), the nun praying the day out, the wounded knight for a late task. Same text box, same two seconds.

Nothing here is minted: every animation is a fact of the record — where you stand, what's late, what you just proved.

And: "when I try to add something it brings up a separate element when it should work from in frame." Fixed. + ADD A TASK no longer raises the note sheet over the machine — the row itself becomes the line: type in the frame, ↵ saves, Esc/B closes. The task lands on the board the same instant (optimistic row, swapped for the real one when the record answers), and the typed line files straight to /api/sites/open-items — the sheet only opens as the no-words fallback. Verified on the pad: type → ↵ → '1 OPEN · torque the lugs on panel 4 · PROVE' standing on the board.

The halves are gone. The 'day' screen is THE TASKBOARD now: one list — the job's open tasks (A proves one with the lens), + ADD A TASK always in reach, what closed today as plain ✓ ticks, and SEND THE DAY as the last row, so the loop's close lives where the tasks live. Cursor-only rows (the menu's grammar), ▴▾ walks, no tabs, no time-of-day heuristic deciding what you meant.

The PLAY strip (the old daily-mission space) reads TASKS now — 'N OPEN · next task → BOARD', 'ALL CLEAR → SEND THE DAY', or 'NONE YET → ADD ONE' — and opens the board. What fell out: the boardHalf state, the 3pm heuristic, the DEBRIEF tab's shots-tray/THE LINE/shadow-draft rows (the send still holds the day; the shadow's draft still lives where SEND runs). Verified on the pad: strip → board → ADD cursor → send row → B back to PLAY.

The chest economy is deleted — coins, chests, rarity, unlocks, all of it. The YOU screen is a closet: every one of his 256 layers and all three companions are yours from the start; ◂ ▸ and you're dressed.

The art now goes into BEATS — a Gen-I text box on PLAY that says what just happened and is gone in two seconds, the operator cheering under it: TASK CLEARED! when a proof lands (the slime pops), A WILD JOB APPEARED! when the Dex grows, THE DAY IS DONE HERE the first time a job has nothing left to prove and something shot, and <JOB> · FULLY RECORDED when its meter hits 4/4. Every beat is a fact the record just produced. Nothing to earn. Everything reacts.

The Dex entry's third row is SHARE, a page in the pad's own grammar: THE LINK (open · 5 days left, made 2 hours ago — A shares it again), TIMER (◂▸ 1 day / 7 days / 30 days / no expiry — A makes a new link that lives that long and hands it to the share sheet), and KILL EVERY OPEN LINK on two presses, B keeps them open. The whole day-draft and SEND THE DAY flow is unchanged underneath.

And PLAY was crammed — his words — so the day's board no longer unfolds over the field. PLAY keeps ONE line (BRIEF · 2 TASKS · …, or DAY · 6 THINGS · SHADOW WRITES IT ▸ once something landed and no line is written — the beat that was going unused as a banner), and pressing it opens THE DAY as its own page: BRIEF and DEBRIEF halves, the line in its own frame saying who wrote it, LET YOUR SHADOW WRITE THE DAY as a real cursor row, and SEND THE DAY. Rendered and walked headless: PLAY → DAY → both halves; DEX → entry → SHARE → timer dial → KILL armed and disarmed by B.

A TASK IS A WILD SLIME. His slime stands in for every open task — green undated, blue with a day, red late — on the BRIEF rows, on the Dex entry, and as a pack of up to three at the job's feet on PLAY. A proof shot pops one.

THE DEX FILLS. A job with nothing on file is a silhouette with a ? and reads SEEN; the first capture turns it into its own face — CAUGHT. The Dex head counts 2/3 CAUGHT. Every entry carries a RECORD meter of the four kinds a full entry holds — PHOTO, WALK, CLIP, PAPER — so 4/4 is a job fully documented.

THE LEVEL-UP. A job's level is its days worked. The first open after a new day was worked prints GREW TO L4! on its plate for a beat and the operator cheers. Once, honestly, off the record.

What I did NOT wire: the healing-items sheet — nothing in the record is a potion, and a fake mapping would be the kind of gamification that loses the point.

Folded, the day is one line in three states: BRIEF · 2 TASKS · SHOOT THE FRONT (A opens the board), BRIEF · NO TASKS TODAY · ADD ONE, and DONE · 4 THINGS TODAY · SEND THE DAY.

Unfolded it's one Gen-I window with two halves. BRIEF: this job's open tasks as cursor rows, dated ones first — ▴▾ walks, A proves the one under the cursor with the lens, LATE prints on an overdue one, the last row adds a task (the note sheet with the switch already on). DEBRIEF: what landed today, what closed (✓), what carries to tomorrow's brief, the shadow's signed line and the key to let it write or rewrite the day, and SEND THE DAY. ◂▸ flips the half; the board opens on the brief in the morning and the debrief after three or once there's nothing left to prove.

Tomorrow's plan already reads open tasks, so what you don't shoot today is tomorrow's brief without anyone typing it.

The DRAFT page shows it all under a cursor. A signs the line — it lands as today's mission stamped WRITTEN BY YOUR SHADOW · SIGNED BY YOU, and the board says so under it. A on a closure closes that task with the proof photo attached and closed_by:'shadow'. B throws the rest out; nothing unsigned ever touches the record. Haiku, a fraction of a cent a day. You come back to a day already written and you just correct it.

The foot breadcrumb ("B ◂ …") sat at z-index 3, on top of the LCD grid, which broke the frame-to-bezel illusion at the bottom edge. It's z-index 1 now, under the matrix (z:2), so the grid runs over it to the bezel unbroken.

The SWAP-cartridge control on the PLAY plate was a bare ⇄ glyph, easy to miss and fiddly to hit. It's a visible square chip now — 42px, a hairline border, a soft fill, more space — bigger, clearer, and a real target. Verified the chip and the breadcrumb z on the pad.

The page itself now opens with the shadow — greyed, as it looks on the pad — and ASK THIS JOB'S SHADOW: whoever holds the link asks, and every answer arrives with the photo that proves it. Read-only: it speaks for the record, never edits it. A worker's shift shows as ONE entry in the shadow's own words (its debrief), never its frames one by one.

OBSERVABILITY (Kymani: "documentation and validation are real work, I cannot afford to fuck up"): every question a visitor asks lands on the job as an ASK marked FROM THE LINK — the question and the answer the shadow gave — so you can see exactly what your shadow was asked and what it said. Next, with the same rule: the shadow writes your day, and nothing it writes enters the record unsigned.

Viewfinder, two more from the field: below the tool name a very short line now says what it does ("A 360 walk — the X5 records the room", "Find the part in the shot", etc.), and the camera-flip button moved up off the boom bezel it was underlapping. Built clean; the live viewfinder still wants a look on the device.

Reticle removed — the corner-frame and per-mode crosshair over the shot are gone (and the dead RETICLE table with them). The frame is the viewfinder; the mode label below says what the lens will do.

The mode dial was pinned to the bottom of the glass, so the pad's boom bezel clipped it. The controls now lift into the safe area (bottom padding = max(safe-area, 22px), a stronger scrim, the dial nudged up), and the active mode reads bright white and bold with a shadow instead of a dim per-mode ink on a dark scrim. Built clean; needs a look on the device (the live viewfinder can't render here without the camera).

Where the words go: the results screen says them first, before any number (YOUR SHADOW IS WRITING WHAT HAPPENED… until they land); the tap on your shoulder carries the first sentence ('Your shadow is back from Redland'); the file's SHIFT entry wears them; and ◂ ▸ on the results screen opens ASK scoped to that one shift — its frames and its debrief are the whole record for the question, so 'who was that at 2:14?' answers with the frame. Every shift-banked frame now carries shift_id, which is what makes the scoping honest. Box side lands on its next git pull; the phone rig has it after this deploy.

The pad is client-only now — no server HTML for it, so nothing to mismatch. It boots itself, which it was already doing.

The pad read the stored theme (dark/tint) inside the useState initializer. Next server-renders this client component with the default LIGHT theme, and React does not reconcile inline-STYLE differences during hydration in production. So the first client render computed the stored (dark) colors while the live DOM still held the server's light ones — and because the component already believed it was dark, no later render produced a diff to patch, so the wrong colors stuck until a brand-new element rendered or you toggled the mode.

Fix is the standard theme pattern: server and first client render are BOTH the light default (clean hydration), then a mount effect reads localStorage and transitions the theme, which React patches. Verified: a stored dark theme paints light-ink on load, a light/first-time user paints black ink on load — neither needs a keystroke.

So his frame, bar and buttons are re-drawn at build time as ink: each piece becomes an alpha mask (his outlines strongest) filled with the glass's own ink — six of them, one per tint, cream and blackout — and the pad picks the file for the glass it's on. The six status icons get the same treatment, each normalised to its own range so a red slash isn't lost. Emotes and the album's item icons go through the four-tone filter instead.

Same art, same corners, one machine.

A job that owes you wears his ! — and a job that owes nothing and has nothing filed today wears his ?, the Pokémon question: what next here?

A fox or a dog runs while a worker is on the clock at this job or the record is being asked; otherwise it sits. SWAP and the Dex entry's option list are his buttons (the lit state under the cursor).

The entry was already Gen-I-shaped but split into four bordered boxes (identity / address / flavor / options). A real Pokédex entry is ONE framed page: sprite + name + species + two numbers up top, a rule, then the description. So it's one card now — sprite and the HT/WT-style readout (GROUND / DAYS) up top, the address as a single tappable line, a hairline, then the flavor text (what's on file, last worked, what's OWED). The action list (LOAD JOB / OPEN FILE) sits under a hairline below the page, cursor-only, the way a menu sits under a Gen-I screen.

Every interaction preserved: the address line still opens the doors, each OWED line still opens the lens to prove it, ◂▸ still flips jobs, ▴▾ walks the options. Verified on the pad.

HIS FRAMES ON THE BOXES (Kymani: "the device looks great, leave as is" — so the shell is untouched; his frame goes on the SCREEN's boxes only). Every window on the glass is GandalfHardcore's 64x64 frame, nine-sliced so the corner scrolls stay whole. Our drawn rivets retired — his frame brings its corners.

The CLR bar is his slider bar. The FILE's KIND dial wears one of his item icons for the kind you're on. VOLT wears his emoji bubbles — ? while it thinks, a grin while it speaks, a frown when the line drops — and the one on PLAY pops a ? while the record is being asked. And when ATTACK lands, his projectile burst hits the job plate.

Everything still comes from one build script and sources that never enter git.

Removed the background from the option rows. It's cursor-only now — the ▶ is the single indicator, the selected label a touch brighter — exactly the main menu's grammar. Nothing else changed.

Done. The option bar was two boxes side by side under a vertical page — which read wrong. It's a vertical list now: LOAD JOB over OPEN FILE, words flush left with the ▶ cursor, the exact grammar of the main menu. ▴ ▾ walks the list; ◂ ▸ flips to the next/prev job (the way Pokémon flips Dex entries), and the header's paging arrows changed to match (◂ 1/3 ▸).

YOUR LOOK. The operator is a loadout composited live from 256 of his layers — skin, hair, hat, shirt, pants, boots, gloves, back, face, in-hand — ten slots, him or her, plus a companion (the wisp, a fox, a dog). The YOU screen (your plate on PLAY, or SETTINGS → Your look) is a Gen-I list: ◂ ▸ change a slot among what you own, and every row says how many things are still locked.

THE COINS. The only currency the record can vouch for: every owed line you clear WITH A PHOTO is a coin. Nothing else mints one. The purse sits on your plate with his spinning coin.

THE CHESTS. A coin opens a chest — twenty of his, thirteen frames each, with the rarity glow — and it hands you one thing you didn't have, weighted so hats, backs and faces come rarely and companions rarest. What it hands you goes on immediately; your sprite cheers. Unlocks and the look live on this phone for now (said plainly on the screen's own terms).

AND THE REST. A job that owes you wears his exclamation marker over its head on PLAY; a proof shot landing fires his buff sparkle on the site; the capture dial shows one of his 600 item icons for the mode under the mark; and his frames, bars, buttons and paper are shipped ready for the pad's boxes. Everything from the packs is built by one script from sources that never enter git.

Renamed everywhere the creature lives: the PLAY slot, its page, ULTRASHADOW (the all-four move), the shift labels in the file, the results screen, the box's policy table, and its voice — it now speaks as your shadow ('you know this job because it is theirs'). Untouched: every 'volt' that means voltage in the electrical routes. The sprite is next: the other session is rebuilding the sprite system; when it settles, the shadow is drawn as your own avatar in dim ink.

The new-job form got two fixes he called out: a ‹ BACK button at the top (and Escape closes it) — before, the only way out was a CANCEL the keyboard often covered — and it stops resizing when the keyboard opens: the card measured its height in 100dvh (dynamic — shrinks with the keyboard), now 100svh (stable), the same fix the home pile already uses.

Left untouched on purpose: the Dex address view (he felt it was 'weird') and 'should the naming page exist at all' — that surface is being actively rebuilt in a parallel session, so editing it now would collide.

Now the ledger skips every worker-banked frame (they stay in the record — ASK still reads them — they just aren't your history) and adds ONE entry per shift: PHOTOGRAPHER SHIFT or ULTRAVOLT SHIFT, wearing its first kept frame (or the live eye while it runs), saying what it kept — 41 kept · 3 moved · 72 min on site, or per-lane P 12 · W 3 · WI 40 · T 2 for ULTRAVOLT. The file gets a SHIFTS kind. A on a shift opens the shift — its results and its reel — never the first frame as if it were a photo. One worker, one item, the array inside it.

THE PHONE RIG runs all four lanes now, ported line for line from the box: each frame scored once, every sample lane keeps its own bucket over the same frame (grabbed at most once per tick), one motion machine serves watchman photos and timekeeper visits, per-lane gate and cap at close. The route banks each pick under its lane.

OBSERVABILITY: both rigs now stamp the job every eye tick with frames seen, the last-frame time, and per-lane counts so far; the shift screen prints a LIVE line under the eye — EYE 4S AGO · 214 FRAMES · P 12 W 3 WI 40 T 2 — and turns the accent with CHECK THE CAMERA if the eye goes quiet for 30 s. A shift that has kept nothing yet still says it is watching. The box picks its half up on the next git pull.

The operator is his free pack layered — hi-vis orange shirt, the mining helmet as a hard hat, a pickaxe in hand — with a five-frame idle, an eight-frame walk, a jump, and a six-frame ATTACK that now plays before the lens opens when you press ATTACK on PLAY. VOLT is the wisp from his pet-companion pack: an electric spirit, five frames, beside you.

The workers are cast from his NPC pack: the Joiner with the plank is the PHOTOGRAPHER, the Miner with the lamp on his helmet is the WATCHMAN, the Blacksmith at the anvil is the WITNESS, the Farmer at the gate with the pitchfork is the TIMEKEEPER — five-frame idles on the party, the card, the dusk row and the shift. The 16-pixel four-tone engine stays underneath as the fallback for any trade without a strip.

The 10x10 one-tone silhouettes are deleted. His colour stays colour on the LCD — the four-tone posterize is still there for photographs, but it was greying the art you paid for.

On the pad: VOLT's page lists VOLT · ULTRAVOLT first under WITH YOU, then the four singles. Its card is No.005 THE CREW. The results screen prints one row per lane — kept / moved / min on site. Every banked photo carries the LANE that chose it (source/worker) plus the shift kind, so the file reads them as photographer shots, watchman events, etc., exactly as before. The phone rig cannot run four lanes yet — ULTRAVOLT on the phone runs its photographer lane, said plainly in code. The box picks up the new policy on its next git pull.

The globe/MAP button is removed from the header; the light and colorway keys stay. The map is reached from its menu row now — one door, not two. openMap still fires from that row and from a job's Dex page (LOAD / FILE / MAP).

The auto-trigger is deleted. THE DAY IS DONE stays reachable by hand (the day-bar press), and the shape we settled tonight folds it into PLAY as the day's LEAVING face — but nothing pops itself open anymore.

Part of a bigger solve tonight: the pad had five surfaces reaching for one idea (OWE, YOU SAID, DAILY MISSION, THE DAY IS DONE, the PLAN). They're not five things — they're ONE thing, the OWE, at five points in its life: proposed (YOU SAID) → taken on (mission) → open (OWE) → proved (PROVE) → carried to tomorrow (the PLAN/SEND). The design: collapse all five into ONE surface — PLAY becomes THE DAY, opening on the job you're standing on, 'N owed elsewhere' pointing to the pile, leaving = SEND tomorrow, no timer, one word (OWE). The full collapse is a clean watched pass, not a midnight race — the PLAY screen is being built from the same direction in parallel.

Same component, same geocoder, same elect-only law (typed words are never an address). Only the face and the keys changed; the card-era face still exists for anything outside the pad. With this, every page touched today reads in the machine's own grammar and is reachable without a finger on the glass.

Audited the rest of what I touched today: the board's camera/↑ and SWAP were already copies of key paths (ATTACK + the dial; MENU → DEX), so they stand. Next: the address picker itself, which is still the card-era dropdown sitting on a Game Boy screen.

So: VOLT is the creature that lives in a camera. In your hand it walks with you (WITH YOU — talk, it sees what you see). Posted on this job's camera it stays ON THE CLOCK while you're gone. Same creature, two states. The four trades — photographer, watchman, witness, timekeeper — are its MOVES, picked when you post it. VOLT's page is reached from PLAY only (ATTACK · VOLT · ASK) and shows VOLT on THIS job: with you, on the clock here (A opens its shift page: watch, END, FIRE), or POST VOLT · ‹move›. The menu is PLAY · DEX · MAP · SETTINGS — MAP earned its slot back; it is the one truly global thing.

Under the hood they are still two brains — Gemini Live for the awake one, the box's policies for the posted one — but the user never sees that. Running all four moves on one camera at once is possible (same frames, four policies, same cost) and is the next build, not this one: today posting picks one move, as hiring always has, so nothing gets weird.

First slice, shipped: SEND THE DAY stops sending a report of TODAY and sends a PLAN for TOMORROW. New report kind `plan` — 'The Plan' — reasons forward like the load-out and is led ENTIRELY by the open OWEs already in the record (the engine was already pulling them in as 'OPEN ITEM (still owed)' lines). It reads like the message a foreman types into the group chat the night before: WHERE WE LEFT IT / TOMORROW (the owed work, urgent first) / WATCH FOR.

This finally gives OWE a home. It always felt weird as a dial item in the capture tool because an owe isn't a capture — it's a promise. Its home is the plan: an OWE is a line on tomorrow's list, PROVE crosses it off. Pad copy follows: the SEND move reads 'tomorrow's plan', the share text leads 'Plan for tomorrow', the toast says 'Tomorrow is sent to the crew.'

Verified: tsc clean, prod build exit 0, label + brief confirmed shipping in the bundle. NOT yet judged on real data — the quality of the generated plan needs Kymani's own jobs and a live send from his phone. That's the next thing to feel. This is slice one of the loop.

Each trade's card now ends with ITS JOBS: the shift it is on right now (ON THE CLOCK · site · minutes · rig), then its past shifts (date · site · done or did not finish), all on the D-pad — row 0 hires, A on any job opens it: the live monitor for a running one, the results for a finished one.

"Why would A on a shift fire the worker? Don't we have a page for worker things?" We do now. A on a running shift opens its page — on the clock N min, the rig — with WATCH (the eye, the reel, END) and FIRE (two presses, B keeps it). The party rows just say what's running.

And CAPTURE is ATTACK on PLAY: every shot is damage against what the job is owed, which is exactly how a daily mission gets cleared.

The interesting version of 'multiple workers' is a later, cheaper thing: a shift is one camera, but it could carry several TRADES at once — photographer + watchman on the same frames is nearly free on the box (same chunks, two policies). That is a crew on one camera, not two shifts. Parked.

"On PLAY, PARTY takes me to VOLT rather than the party with the workers." Right: PLAY's middle command is the bench now. VOLT is still one press away — its sprite beside yours.

"From the workers menu let me straight up fire a worker — don't even develop, just cancel and delete the work." A on a running shift in the party arms it — FIRE THE PHOTOGRAPHER? — and A again fires: this phone stops the rig, the record marks the job fired, its shots are deleted, and the box reads that mid-loop and stops without banking a thing. B keeps it.

Now the PARTY reads the record — the truth — when it opens and every 8 s: every running shift is a row right under VOLT (PHOTOGRAPHER · ON THE CLOCK · Redland · 14 MIN · X5), A opens it as the owner with END SHIFT live (it adopts the relay session, so END really stops it). If the record says nothing is running, every local marker is cleared — on that party read and at every app boot. No marker can say 'on the clock' over an empty record again.

And the box measures the first frame it decodes and stamps frame_w x frame_h on the job. Three numbers now sit on every shift: asked, camera's word, and what actually arrived. The data cost is only fixed when the third one shrinks. The box picks up worker.py changes on its own between jobs; the phone needs the new build.

The rule: a WORKER belongs to the job it was posted on. On that job's PLAY the crew line says PHOTOGRAPHER ON THE CLOCK ▸ in the accent; on any other job it's a quiet PHOTOGRAPHER · AT REDLAND ▸ — never a lie, and still a way back. The day's facts only count a worker on THIS job. In the PARTY the running trade is marked ON with where it is. VOLT is never job-locked — it walks with you and carries whichever job you're standing on.

Now the box stitches both lenses into one equirectangular 360 per pick, the same projection the walk footage speaks, so the record, ASK's eye and the viewer treat it like any 360 frame. The lens model is measured on a real frame (each circle fills its half; 190-degree equidistant gave the tightest seams on the shop; what's left at the join is lens parallax on near things). The live eye is the same 360, small. The capture row is stamped projection: equirect.

Found on the way, and honest: the same raw frame is 2656x1328 at 5 MB per five seconds — the camera ignored the 1920x960 stream request even though the job stamped it. The small-stream saving has NOT landed on the X5; that's a separate fix.

Now ◂ ▸ turn VOLT's EYE dial — PHONE ⟷ X5 — the same way the camera's dial turns; A talks or reconnects, B puts it away. The legend prints the whole key map (A · ◂▸ EYE · B), so nothing on the page needs a finger. The tap still works for a thumb, but it is a copy of the key, never the only door.

How grounded-only is actually built, since he asked: (1) the model has no corpus of its own — every job fact goes through ONE tool, ask_the_record, which is /api/ask over the account's captures; (2) the tool result is gated in code: when /api/ask returns no evidence, the tool hands the model the fixed sentence "Nothing filed answers that." and nothing else, so there is no prose to embellish; (3) the system instruction states the rule as a hard one — call the tool, repeat it, refuse on empty, never general knowledge, never advice — and it applies to both scopes. What VOLT can answer without the tool is only what's in front of the camera right now.

So the glass carries a small print in its bottom corner — B ◂ DEX, B ◂ PARTY, B ◂ CLOSE THE LINE, B ◂ ALL KINDS — that follows the trail and the layers. It vanishes on the menu, where B has nowhere to go, and while a lens or a shift owns the glass.

Worse, hidden: the JS snapshot fell back to captureFrame() — the camera's REAL shutter, a full photo cycle — so VOLT's 1 fps eye was firing the shutter every second and getting empty frames. VOLT now uses peekPreview(), which never touches the shutter. The strip is 2:1 like the equirect preview (no bars, no crop) and the dead phone mugshot is hidden on X5. The SurfaceView fix lives in Insta360BridgePlugin.java — it needs a new APK on the phone; the web half deploys now.

Now: a dropped line prints LINE DROPPED — PRESS A TO RECONNECT (A becomes RECONNECT), VOLT retries once on its own after 1.5 s, and a LOOKS counter plus X5 FRAMES OK / NO X5 FRAME YET show whether frames are actually reaching it. So the field can tell the difference between 'VOLT is deaf' and 'the internet left with the Wi-Fi'.

The honest edge: if reconnect fails while the X5 is up, the X5 Wi-Fi is holding the internet. The walk relay survives that in NATIVE code (it binds its socket to the camera network and lets the phone keep cellular for the rest). A web page can't choose its network. If that's what we see, the fix is native — expose the same bound-network path to the WebView — not more VOLT code. Also seen: the strip renders pillarboxed (a front-lens crop), while the snapshot VOLT reads is the stitched sphere; cosmetic, noted.

So WORKERS is gone from the menu; the row is PARTY, and it says ON THE CLOCK while one is working. In the party, A on a trade reads its card, A on the card clocks it in on the loaded job — no site picker. The old WORKERS list and the CLOCK IN — WHERE? picker are deleted, not hidden.

When you switch to the X5, the phone camera is now released (Kymani: 'kill the phone footage when using the x5') so it isn't fighting the camera. Dropping back to the phone eye restarts it.

And VOLT's eye no longer reads a worker's frames (Kymani: 'don't reference workers') — it's only ever the phone, or the X5 you deliberately chose. Still device-only and unverified on the camera; first run, confirm the strip fills with the live 360 instead of staying dark.

Now the machine keeps a trail: every screen change remembers the screen it left and the cursor it left it on, and B pops exactly one — worker → workers → menu, entry → dex with the same job under the cursor, the file → the job's page you opened it from. Layers still close first (a line being written, the viewer, the mission editor, the file's lens), then the trail. The menu is the floor. No screen decides where B goes any more; the way you came is where it goes.

Now the state lives in the machine's own ink: a bordered box, plain ink text for waiting/talking, and for YOUR turn the pad's one accent with a blinking ▶ — the Gen-I 'your move' cursor — instead of a glowing dot. Loud enough to read at a glance, in the machine's grammar.

So every NEW JOB is born owing that one line. Claim the ground you're on, the plate says 1 OWED, A on it, one shot, cleared — and the job has its face. That's the wild encounter you repeat forever, not a rival you meet once. Gone with it: the first-site-only rule, SETTINGS → FIRST BATTLE, and the STARTER tag. The line is stamped as the job's own first move so the record knows, and nothing anywhere calls it a tutorial.

Now the token + Gemini socket come FIRST — that is what waking means: hearing and talking. The phone eye is fired in the background where it can never block. If the connection truly can't be reached (the X5 Wi-Fi holding the internet is the usual field cause), VOLT says so plainly instead of hanging. A 12s cap means it never sits forever on WAKING.

And his other question: does replaying the first battle on a live job affect it? Only by one owed line and one real photo, both of which it's told about: the line wears a small STARTER tag on the job's screen and its Dex page, so it can never be mistaken for something you logged, and the proof shot is an ordinary photo of the front of the site — the kind of capture the job wants anyway.

The reset is right, though, and it's a settings row: FIRST BATTLE — replay it on the loaded job. It plants the one line again — Shoot the front of the site. — stamped as the starter, on whatever cartridge is in the machine, and walks you to PLAY where the plate says 1 OWED. Clear it the way everything is cleared. You never have to finish a job to use the tutorial; you need a job to stand on, which is the first thing anyone does.

And the starter enemy, since he didn't want to wait to feel the loop: the FIRST job an account ever claims is born owing one line — "Shoot the front of the site." — marked as the starter so it can never be confused with something you logged. Clear it the way everything is cleared: A on the line, the lens opens, one shot, proved. That's the rival battle outside Oak's lab: it happens once, it teaches PLAY → capture → the record without a demo, and after it the app never makes up an owed line again.

The frame VOLT sees is shown to you too, as a wide 360 strip: the center is straight ahead, the two ends wrap around behind you. VOLT is told exactly that, so it answers about ANY direction — "behind you", "to your left" — real extended vision. DROP returns to the phone eye; leaving VOLT stops the preview. When a worker shift already owns the camera, VOLT reads its frames for free.

Built and typechecks, but the X5 path is NOT yet verified on the camera. First run on the phone: press SEE THROUGH X5 and confirm it flips to the 360 strip and frames arrive; if the button hangs on CONNECTING or the strip stays empty, that is the device path to debug.

Two moves. OWE is a lens on the capture dial now — PHOTO · VIDEO · WALK · … · NOTE · OWE — turn to it, write the line, A. Setting what a job is owed is a capture technique, right beside NOTE, not a switch under one.

And PROVE IT: on the job's screen or its Dex page, A on an owed line opens the lens with the line printed on it. The shot files to the job carrying that line and clears it — capture is the damage, the record is the proof, the CLR bar fills. The box alone still ticks, for the things no camera can see (a call made). No badges, no streaks; the bar was already the reward. The one starter enemy for new accounts is held until the loop has been felt.

The phone's keyboard shrinks the visual viewport; when it grows back while a line is open with nothing to read in it, the line closes with it and the field steps back. An answer on screen keeps the window — that's the one time it's worth something without a keyboard — and B still closes it any time.

So A on a job's Dex page now pops that box: LOAD stands you on the job (the cartridge), FILE opens the album narrowed to that job (B brings you back to the page), MAP jumps to its town, QUIT closes. ▴ ▾ walk the box, B closes it. The tappable THE FILE row it replaces was the only thing on the page a controller couldn't reach.

The PWR bar (the confusing ‘power feature’) is gone. In its place, one loud line that says exactly whose turn it is: green ● LISTENING — GO AHEAD when it’s yours, VOLT IS TALKING when it’s his, MUTED · PRESS A TO TALK when the mic is off. No more guessing.

And: "I'm trying to start another photographer shift and I simply cannot — once a shift starts it never ends." Hiring a worker walked back into the newest worker job on the record even when that job was DONE, so every hire landed on an old results screen. A hire now resumes only a shift that is truly still running; the crew line on PLAY is where you view the last one. A phone shift with no descriptor left on this phone is dead — this phone was the worker — so the record closes it out honestly ("the phone closed before the shift ended"), keeps what it filed, and the hire proceeds.

Kept VOLT phone-first on purpose (his own law: I do not always have the X5). But VOLT can now bring the 360 ONLINE as its eye — connect keeps internet (proxy mode), the native preview is embedded in the little mugshot box, never fullscreen, and if a shift already owns the preview VOLT just reads its frames (it sees what the worker sees). Tap EYE to switch to X5; phone is the fallback. A creature that sees everything around you at once. The X5 path is not yet verified on the camera.

Also from the first real talk: echo cancellation on (VOLT stopped hearing itself), and sight is answered instantly from the frame while only history reaches the record — see = milliseconds, record = accurate.

2) The wordmark prints where a handheld prints it: maker small, model bold, flush with the screen's left edge under the bezel — not centred like a title card. The keys keep the right.

3) PLAY has three core plays — CAPTURE, VOLT, ASK. NOTE moved onto the capture dial with the other lenses, because it IS a capture technique. The message window now says what the play under the cursor does, so the box that asks WHAT WILL YOU DO answers it.

4) Opening the DAILY MISSION used to push your avatar, your companion and your plate down the field; the board is a sheet over the field now and nothing underneath moves.

5) The Dex always says where you stand, whatever cartridge is loaded: the nearest job wears ◉ HERE when you're inside its mile, or NEAREST · 2.3 MI when you're not, live off GPS, and the foot says YOU ARE AT… or NEAREST JOB … AWAY — NEW GROUND HERE.

6) The album's two dials — JOB and KIND — are Gen-I option lines now: ▴ off the top row lands the cursor on them, ◂ ▸ turn them through every job and every kind the record holds, none of it scrolls out of reach. The pills that only a thumb could press are gone.

LATENCY: the prompt routed every job question through ask_the_record, a full Claude round-trip of seconds. Now it splits by speed — what it can SEE it answers instantly itself from the frame (what is this, read that label, how many), and only reaches for the record on history it cannot see (what was done, what is owed, dates). See = milliseconds, record = accurate. That is also what makes it usable as a live extended eye.

The one retro object that IS a contact sheet is the Game Boy Camera's album, so the file is that now: a grid of frames, one cursor, ◂ ▸ step a frame, ▴ ▾ step a row, A opens the frame, B comes back. The frames carry no captions any more — the foot prints the words of the frame under the cursor, once, big enough to read standing up (the bonded pair, kept) — so the grid is dense enough to take in a day at a glance. Days stay: a rule with the day's name runs across the grid where the day changes, because the record is one place across days.

The HISTORY key, pressed again on the file, turns the KIND — ALL, PHOTOS, CLIPS, WALKS, NOTES, PAPERS, MEASURES, READS, ASKS — which is SELECT on a Game Boy. Tapping still works everywhere it did.

VOLT: ephemeral tokens are rejected on the Gemini Live socket in this API build (unregistered callers), and the real key works. So for the demo the phone connects with the key directly — GATED to the owner account only, so it never reaches anyone else browser, until the free in-browser ears/mouth swap removes the client key entirely. Key is live locally; VOLT speaks once the same env is set on Vercel.

The standard cure, applied on review: seek to the end once at load so the browser discovers the real length, then come back to zero. The take now plays and its timeline drags. On the glass the native control bar keeps a strip to itself, and the D-pad scrubs the take five seconds a press — A banks, B re-shoots, ◂ ▸ scrub — so the review works by controller like everything else on the pad.

The map is where you LOOK; the dex page is what a job IS. A on the map now opens that job's dex page, exactly the one the DEX list opens, and B from there returns to the map rather than the dex list. Loading it and its tools come after, the same way they do from the dex.

The fallback is now the RECORD itself. Tapping the crew line (or picking the worker) asks the account for its newest worker job: still processing → you walk into the live monitor and can END it; already done → you land on its RESULTS, which is also how you view the last shift. Rig is read off the job. Browsing the full history of shifts is a separate list still to come; their deliverables already land on the card.

onTower now checks for a running shift first (the resume descriptor written at clock-in) and walks straight back into it as the owner — live monitor, END available — wherever it was started. Only when nothing is running does picking a worker begin a fresh connect. Shifts started before this ship have no descriptor and can’t be resumed this way; the next one you start can.

Walking back in: the crew line on PLAY — WORKER ON THE CLOCK, now orange with a live dot and a ▸ — reopens the shift. It resumes from a descriptor written when the shift clocked in (job, ground, trade, rig), so it survives even a reload. A resumed shift you OWN can END from there; stopWorkerShift/stopPhoneShift are module-level, so ending never needs the original screen. Only a shift resumed from someone else’s push stays read-only.

Built: VOLT, a bolt-eared mouse in fire, stands beside your avatar on PLAY. Press it and its page opens on the glass: status box (LISTENING / HEARING YOU / ASKING THE RECORD / SPEAKING), what it heard and said, a thumbnail of what it sees. A toggles the mic, B puts it away. Eyes: the X5’s live preview when the walk card has one up, else the phone’s back camera, one frame a second. Voice: Gemini Live on one WebSocket straight from the phone (audio cannot take a Vercel hop per word) holding a single-use ephemeral token minted by /api/companion/token — never the key. Its ONE tool is ask_the_record → /api/ask, so every job answer is the record’s, with proof frames.

Not yet proven: both Gemini keys in .env.local are revoked relics (Google: "API key not valid"; nothing in the app used them). The whole loop is written and typechecks; it wakes the moment a live GOOGLE_GEMINI_API_KEY is in .env.local and Vercel. Found on the way: v1beta auth_tokens rejects liveConnectConstraints, so the model lock lives in the setup message instead.

INSTANT: the mission and today’s rows are kept in the phone’s own storage and painted on the first frame; the wire only corrects them, and nothing is cleared while loading (the old loader blanked the line, then fetched — that was the flash). NO SQUEEZE: with the board open the field scrolls instead of spacing its children to the ends, and the editor is its own page on the glass — a textarea the keyboard can push, SAVE THE MISSION, ✕ or B — so nothing can stack on the keys. UPLOAD: an ↑ key beside the camera on the board opens the tray; it files to this job, today, like everything else on the board.

Now the board re-reads on two triggers: home bumps a counter whenever anything lands (a photo, a clip, a note, an upload), and coming back to PLAY after half a minute re-reads on its own — the phone was in a pocket, the day moved. The board is called DAILY MISSION, opens from a +, closes from a −.

Opening a job’s DOORS page now asks the ground: every worked pin is clustered into spots; a spot counts only if it holds two or more separate capture events — the same growsGround rule that decides what grows the ground, so one ladder photo shot at the shop never becomes a door. The card’s own address and every listed door are skipped; the rest are reverse-geocoded and filed as derived doors carrying FIRST, LAST and how many days were worked there. They print with a ● and the line NOTICED · WORKED 3 DAYS · FIRST AUG 12.

Taking a noticed door off tombstones it instead of deleting it — the ground is still there, and a deleted row would only be noticed again tomorrow. Budget: four reverse geocodes per open, Photon only. New /api/sites/doors and lib/geo-reverse.ts. Unproven live until Kymani opens a job’s doors on the phone.

Gen I never did that. The Pokédex is a LIST of rows with a ▶; A opens ONE page for the thing under the cursor; ◂ ▸ flips pages; B comes back with the cursor where you left it. That is now the mechanic. The list is just No. · face · name (ON if loaded, a number if owed). The entry is sprite left, name / town / GROUND / DAYS right, an AT line, and a text box that says what is owed, how much is on file and when it was last worked — plus THE FILE. A stands you on it.

Cut from the entry, not lost: the eight kind keys (the file’s own chip row does that), the 70-day strip (pretty, not actionable), and the address list, which moved to its own DOORS page behind the AT line — change the card’s address, add another, take one away, all elected from the search list. The next move on doors is to DERIVE them from the ground you actually worked and date them, so nobody types an address the record already knows.

A second address is a captures row (kind=address), the same no-migration pattern papers and day notes use. It deliberately carries no gps: a capture’s gps is a spot WORKED and grows the ground; an address you typed is a fact about the job, not a place you stood — its coordinates ride in `addr` where nothing that walks gps ever sees them. Kept out of the day ledger for the same reason; ASK can still read it ("Also at …").

Every address, primary or extra, is elected from the search list (AddressPick, Photon) — free text never writes one. The picker opens on the glass; B cancels. New route /api/sites/address (POST elect, DELETE by id), owner-scoped like everything else.

It now paints INSIDE the glass exactly the way the photo lens does (frame=glass, the same fireRef/backRef/dialRef contract). A records, A stops, A banks; B backs out one level — drops a take under review, stops a take in progress, leaves when idle; the D-pad drops a ⚑ MARK while filming. No shutter is drawn. What floats over the frame is the legend for those keys and a thumb-sized ⚑ MARK, which is a moment, not a shutter. The card’s full-bleed recorder is untouched — it only appears when the device is not on screen.

Checked the others: PANEL and PART already ride the photo lens; WALK 360 is the X5’s camera, not the phone’s; MEASURE is an ARCore path, no viewfinder. On the debrief: nothing to toggle — the day-closes trigger already opens it 45 minutes after the last thing lands. DEBRIEF is the manual door on top of that. Not yet proven on the phone: open PLAY, CAPTURE, dial to VIDEO, press A.

THE FILE: every frame now wears what it IS, top right — PDF, IMAGE, VIDEO, 360, TEXT — so a paper and a picture are never confused before they open. The kind keys wrap into two rows so all nine are on the glass and every one is a target (they used to run off the right edge). A paper opens beside the app in its own tab, never over it.

THE DEX: the plate says which job this is of how many (No.003/015) and how much is on its file (44 ON FILE). The 45-minute auto-debrief was considered and NOT added — Kymani: "honestly manual is better for now." DEBRIEF stays a key you press.

ASK left nothing — the record answered and forgot. Now the question, the answer and the ids of the frames that proved it are one row under the job it was asked on (kind=ask), owner asks only, and those rows are kept OUT of the ask corpus so the record can never cite its own earlier answers as evidence. PART FINDER left nothing; it now files the part it named, wearing the photograph it read it off. PANEL reads were being filed but showed up in the ledger as NOTES; they and parts are now READS.

The Dex plate grew READS and ASKS keys, and — found on the way — the sites API never sent note, clip or measure counts, so NOTES/CLIPS/MEASURES printed 0 on every job. The plate now counts the ledger with the same mapping the sheet filters by, so the two cannot disagree. Not yet proven on a live account: ask one question on the phone, open the Dex, press ASKS.

Left and right on the D-pad now walk the shift lengths on the terms beat (1 HR → 2 HR → 4 HR and round), through the same dial hook the camera lens already used; the overlay routes the dial to whichever face is up.

So there is a second rig, same trades, same screens, same results. When no X5 is linked or found, the hire screen offers THIS PHONE: its own camera is the eye and it does the worker's thinking itself — the box's motion and sharpness math ported line for line (a 320-pixel copy against the scene's running background, the same 0.004 / 0.35 thresholds, the same buckets, events, blur gate and cap), so a phone watchman and an X5 watchman agree on what "moved" means.

That is also the most efficient a worker can be on a phone: what leaves it is one JPEG per pick and a thumbnail eye every ten seconds — kilobytes an hour, no relay, no shop box, no cost — and it runs on any phone the app runs on, iPhone included. The paperwork (job row, storage, the captures rows the record reads, the tap on your shoulder) is one route, /api/scan/shift, with your session as its proof. The monitor, the results screen and the notification's deep link work unchanged because it is the same job row.

Honest limits, printed before you hire: the screen has to stay on (a page in the background loses its camera), so plug the phone in; and a phone sees one way, not all round. Run end to end against a fake camera on the laptop: clock-in, the eye, one continuous event closed at END, the shot filed, the results screen. Not yet run on a real phone.

THE LIBRARY. The one file (THE FILE, the contact sheet) already held everything — the trouble was the door and the dial. Now every count on a job’s Dex plate is a key: press PHOTOS and the sheet opens on that job’s photos and nothing else; a LIBRARY key under them opens everything on the job. On the sheet itself a second row of keys — ALL · PHOTOS · CLIPS · WALKS · NOTES · PAPERS · MEASURES, each with its count, zeroes included so the row never moves — narrows by kind. Every kind opens: photos and clips in the viewer with their note, walks into their footage, papers to the file, and notes and measures now open BIG as words on paper (they used to do nothing when pressed). B walks it back one dial at a time: kind, then job, then the Dex you came from.

THE FIELD. The TODAY board had filled the ground between the two fighters, and a Gen-I field is empty ground. It folds to one dashed line — TODAY · what the day is (or NOTHING YET TODAY) · WRITE IT ▸ — and unfolds on a press when you actually want to write on it or look at the day’s shots. Same board, same data, just not standing in the middle of the fight.

A parked worker throws 99% of that away. It keeps one frame a minute or one per event, and it scores motion on a 320-pixel copy. So a shift now asks the camera for the smallest stream its deliverable survives: a watchman or timekeeper proves that something moved and when, and streams at 1440x720 (a person is still plain at 720 pixels per lens, about a quarter of the pixels); a photographer or witness hands back photographs and keeps 1920x960 (about half). A walk never comes through this door — the footage is the field record and keeps the full stream.

The ask is checked against what THIS camera says it supports and falls back to the full stream out loud, never silently: the phone stamps the stream it actually started on the job (stats.stream_res), and the box develops each shot at the size the stream really has instead of inventing blur up to 1024.

This is a native change, so it needs the new APK on the phone. The fractions above are pixel ratios; the bytes the camera really sends per hour at each setting get measured on the first real shift and written back into the table. The motion thresholds were measured on full-size frames — the differencing already ran at 320 pixels, so the domain is unchanged, but that too gets confirmed on hardware before anyone trusts a night's verdict at the new size.

The line is back to one data type: what is owed, and where. The debrief still comes to you by itself when the day closes — that trigger never lived in the line. The 45-minute countdown machinery that only the line read is deleted with it.

The cartridge is gone as an idea and a SWAP key stands in its place, under the job’s placard on PLAY — the one screen that is about a job (Dex, Workers, Settings are global). The Pokémon Go rule: you can open the Dex anywhere, you can only catch where you stand. So PLAY opens on the ground under your boots when the phone knows it, the placard says HERE or NOT HERE · 2.3 MI plainly, and SWAP walks you into the Dex to load another job deliberately. That choice now survives a reload.

Nothing here can be cheated: a photo shot far from the loaded job still files to it and still refuses to grow its ground (growsGround, 2026-08-18). Hard-gating PLAY to your location was considered and rejected — it would kill the commonest real use, reading a job’s day from the truck or the couch.

Now the moments that matter FIRE a notification: the eye opens / the first frame files (once), something moved or someone arrived (the first at once, then no more than one every ten minutes carrying the count so a busy gate can't bury you), and shift over with the number that answers the worker's question. Tapping it lands on that shift's own screen — the live monitor while it's still on the clock, the results screen once it's done — never on home.

Plain Web Push, no third party, no cost: VAPID keys, a push_subscriptions table, /api/push/subscribe for the browser and /api/push/fire for the shop box, which proves itself with the service key it already holds. The words are written server-side from the job's own stats, so nothing can put words in a worker's mouth.

The permission ask lands on clock-in — the beat where "I'll tap you when something happens" is obviously true. Honest limit: the relay phone parked beside the camera is a Capacitor WebView, which has no Push API, and it isn't who we're calling anyway. The tap reaches every OTHER browser you've signed into: a homescreen PWA, laptop Chrome. Dead subscriptions are dropped on the spot.

The machine is better placed to ask than he is to remember, because it can see what is MISSING. Every question exists because a specific row lacks a specific field: a photo with no note ("What is this panel?"), a walk with nothing said about it, a job worked today that never got a scope. Never a model guessing there might be something worth asking — it is arithmetic over the ledger already in memory, and it costs nothing.

Up to two questions print above THE READ on the day page, each with a thumbnail, the site and the clock, and a four-word answer box. The answer lands where the hole was — a photo note goes back onto that photo, a scope goes onto that day — never into a new pile. ✕ skips one.

So the region is fetched when the MACHINE WAKES, not when the map opens. By the time a thumb reaches the globe the land is already on the phone's disk and the map draws it synchronously. One request per region for the life of the phone: a module-level promise stops two callers racing, localStorage stops tomorrow asking again, and the edge holds it a month for everyone else.

A second bug underneath it: the bounding box was rounded with toFixed, which rounds to NEAREST — so on a negative longitude the eastern edge walked back INSIDE the region and quietly clipped the sites at its rim. The low corner floors and the high corner ceils now, so the box always contains what it was asked to contain. Measured on his spread: the box grew from 39.2/-76.6 to 39.3/-76.5, which is the difference between cutting Glen Burnie off and holding it.

And on a first-ever run the map says DRAWING THE LAND in one faint word, because an empty grid with no explanation is exactly how a feature comes to read as broken.

The shutter treatments — A's lit rim, the SHOOT silkscreen, and CAPTURE turning dark and becoming a close-the-lens key — were all keyed off there being ANYTHING on the glass, from back when the camera was the only thing that ever took it. A worker shift uses that same slot, so it inherited camera clothes it had no business wearing.

The real damage was the capture key: while a shift was up, pressing it ran close-the-lens, which meant the camera button was a second way to shut down somebody's running shift. Now the shutter is inert for anything that isn't a lens — dimmed, marked unavailable to screen readers, and it does nothing at all.

Only a real lens arms the shutter now. Verified both ways: with a shift on the glass, A says SELECT with no ring and CAPTURE is disabled; with the camera on the glass, A says SHOOT with its lit rim and CAPTURE closes it.

So the box on the encounter is THE DAY BOARD now: the line he set, a camera key that appends a photo without composing anything, thumbnails of everything that landed on this job today, the count, and a DEBRIEF key that opens the read which closes it out.

His fear about disparate data is answered by the substrate. Nothing appended here is a new kind of thing: a photo from the board is an ordinary capture on that job stamped today, a line is an ordinary day note. The same rows the debrief already reads, ASK already answers from and the file already shows. The board is a VIEW of today, never a container - which is exactly why adding to it cannot strand data nothing can verify.

The day line above the bezel looks like a key now, because he said he would not have known it could be pressed.

And on the keyboard: I did not build one. A hand-made QWERTY loses autocorrect, swipe, dictation, his dictionary and every accessibility affordance - on a jobsite in gloves that is slower and wronger than the board Google spent fifteen years on. What actually broke the flow is that the keyboard DEFORMED the machine: the device is a fixed full-viewport object and Android opens a panel over the bottom half of it, and nothing here was listening to the visual viewport. The machine now resizes to the room the keyboard leaves, keys and all. And the fast writer is words, not letters: the strip above the line is built from his OWN notes, most-used first, so three taps compose a line no keyboard could beat.

On the Game Boy, no. Gen I and II tell you nothing about buttons. A blinking ▼ means there's more and you should press A; a ▶ means this one is selected. The manual covered the rest, because the machine had two buttons and everyone already knew.

But every Pokémon since the DS prints a button legend, and Sword/Shield and Legends: Arceus keep one in the corner permanently. So it IS a Pokémon convention — just a modern one rather than a 1996 one.

The deciding argument wasn't authenticity though: this machine ALREADY prints exactly this legend on its shift screens. So the real choice was between having one convention and having two. The roster and the card now use the same one — a small orange A with its verb on the left, a dim B with BACK on the right, sitting right above the actual A and B buttons on the shell.

The old ▼ and ▶ stay exactly where they were. Those are the period-correct signals and they're still doing their job.

So they separate. The scope stands in the MIDDLE of the field, where nothing covers it and it takes no press to read - the one thing on that screen you should always be able to see. The message window goes back to belonging to the verb: it asks what you will do, and it holds the line while you do it.

And the line closes when the cursor walks off the key that opened it. A line belongs to the key it came from; leave the key and it has no owner. Verified by driving it: idle shows the day and the prompt, NOTE opens the line while the day stays put, and one press of the pad closes it again.

So: the portrait sits in a hard-edged frame instead of a rounded tinted tile. The measures are set in the machine's pixel typeface, in two tight columns — a fixed label, then the value right beside it — instead of a label on one margin and a number flung to the other. A rule runs the full width. The description follows it immediately in the page's own type and fills the rest of the sheet, ending in the arrow.

That last part also fixes the dead middle: pinning the text to the bottom of the screen left a hole in the centre of the card, and a page doesn't have a hole in it.

No dialogue box around the entry, deliberately. A box is for what somebody SAYS; a Dex entry is printed, and boxing it would have been the same mistake in the other direction.

The line closes the way anything on this machine closes now. B backs out of it before it backs out of the screen, whichever verb you press next owns the window, and leaving PLAY clears it. The header carries a visible B CLOSES so the way out is never a guess. ASK keeps its answer until you back out, because an answer you cannot read is not an answer.

His character floated high because deleting the old middle block left the two fighters stacked at the top of a field with nothing between them. They hold the ends of it again.

And UPLOAD opens the phone own picker instead of summoning a drawer. The tray was always the visual picker he was asking for - thumbnails, per-item removal, one SEND - it was just reached through an overlay over the machine. Now the key opens the device picker straight away and the tray it fills paints inside the glass with every other capture surface.

The rows were floating tinted pills with rounded corners — a web list item. The list was vertically centred, with air above and below it, so nothing sat where a handheld would put it. And the line describing the selected worker sat naked at the bottom of the screen.

A Gen-I party screen does none of that. It packs the list against the TOP, marks your choice with a ▶ and nothing else — no highlight, no card, no shadow — and puts every word the game says to you inside a bordered box at the foot of the screen. The row's own facts sit right beside the name in fixed columns instead of being flung to opposite edges, which is what stretched a row into a table on a wide screen.

Same workers, same sprites, same words. It just stands like a handheld now instead of a page.

NOTE and ASK stopped throwing a sheet over the machine. Both open a single line INSIDE the message window, which is exactly where a Gen-I battle prints text. A note files straight to today with no form to fill; a question streams the record answer back into the same box through lib/ask-stream - the one transport, so the glass can never disagree with the card or the world about what the record said. This is a third rendering of that transport, never a second implementation.

And the day moved into the message window. Kymani: the WHAT WILL YOU DO section is the perfect space for the daily scope rather than the middle of the page - the user naturally looks there for their character. Right, and it was a label sitting where content belongs: a rhetorical question printed in the one box the battle uses for everything it has to say. The middle of the field is clear now.

The debrief line is unconditional. He has told me three times he cannot find it, and every time it was gated on having already captured today - so on every morning and every quiet day it rendered nothing. A control that stays invisible until a condition you cannot see is met is not a control. It now states the day state whatever that state is: QUIET, a countdown, READY, or SENT, and pressing it always opens the debrief.

Dusk is MEASURED for that patch of ground, not guessed from a clock. "After 6pm" is two hours wrong in June and wrong the other way in December, and a worker that offers itself at the wrong moment is worse than one that never speaks. The math is the standard sunrise equation — pure arithmetic, no network, no key, works in a truck with no signal — and it lands within a minute of the real sunrise and sunset in Rockville across both solstices.

It appears 45 minutes before sunset rather than at it, because the moment worth asking whether something should watch the site tonight is while you're still standing there packing up, not once you're on the road.

THE PARTY: the roster draws like a party of four, because that's what it is. The bar next to each name isn't HP, it's how much of the shift is left, so the one that's out visibly drains while the rest sit full.

THE CARD: pressing a worker opens its entry — a number, a job title, what it can see, how long it works, what it costs, and a paragraph nobody else has. The boring load-bearing facts, dressed as flavour instead of a spec sheet.

THE DAY CARE: hiring is a conversation now. The worker speaks first and asks for the job — its line types itself out, and the arrow that means 'press A' only appears once the line has finished, because showing it early would be a lie. Then the terms, then yes.

THE RESULTS: a shift used to end in a toast that slid past. Now it ends with what it did while you weren't there — what it banked, what moved, who was on site and how long, and the record bar growing. A quiet night gets said in words rather than shown as a row of zeroes, because for a watchman that's the good outcome.

One shared ticker drives every sprite on screen and stops dead when the tab hides — a worker's shift can run all night with the phone in a pocket, and a screen nobody is looking at must not spend the battery drawing frames.

Rewriting three more sheets to paint in a box would have been three more chances for them to disagree with each other. So the fix is structural: the slot inside the glass now carries a transform, which makes it the containing block for any fixed-position descendant. A sheet that says fixed inset 0 then means fill THE GLASS, without knowing anything changed. Home portals the sheets into that slot while the machine is on, and renders them where they always were when it is off, so the card app full-bleed camera is untouched.

That is a law now: on the handheld there is exactly ONE viewfinder and it is the projection. Any new capture surface goes through the slot and needs no code of its own to do it.

And it stops disappearing when the lens opens. A key that VANISHES is a phone app pretending to be a machine - nothing on a real device evaporates because a mode is running. What a real one does is stay DOWN: the lens is open because this key is held, so it sits latched, sunk in its well with its light gone, and pressing it again releases and closes the lens. The face never changes shape and the state of the machine is legible from the chassis alone.

A wears a lit rim while a lens is up, because A is the shutter then. A ring you see mid-aim beats a word you have to read.

Every capture tool now has its own reticle on the frame - the shape of what is about to happen, sitting on the thing you are already looking at, instead of a word in a dial you must read while aiming. The colour is not invented: each tool wears the SAME ink its artifact already wears in the record. A clip is the orange it is on the card and in the file, a walk is the violet the world draws it in, paper is the gold. So the reticle is a promise about what lands in the record, in the record own ink. PHOTO keeps plain white corners because a photograph is the default and defaults should be quiet.

It was pure duplication. A already fires the identical code through the camera's fire ref, and does more than the circle ever did: with a frame under review A is KEEP, and on any mode other than PHOTO it hands off to that tool. The plate says SHOOT while a lens is up, so nothing about it was hidden.

A touch target drawn on the screen of a machine that has hardware keys is the phone app leaking back in. It teaches the wrong gesture, and it sits on top of the frame you are trying to aim.

Off the handheld the circle stays. The card app's full-bleed camera has no keys to press, so there the button is the only shutter there is.

The Dex got sized for arm length. Seven-pixel labels read fine on a laptop and vanish in a gloved hand in daylight, which is the only place this screen is ever used. Bigger type throughout, rows at a real thumb target, and the ruler with its right-hand column is gone - four sort modes were four things to read before you could look at what you came for.

The cursor keeps itself in view. Walking down fifteen jobs used to carry the selection off the bottom of the window while the list sat still, which is exactly how you lose your place.

And a self-inflicted one worth recording: writing a prose comment INSIDE the style template broke hydration. An apostrophe in there is enough - the whole root falls back to client rendering and the app reads as glitchy on every open. It is a documented law in this repo and it still caught me. Style tags carry bare rules only; the words live outside the tag.

The day stopped being a tab. He said it should be just text somewhere, not an entire tab, and he was right: a row is a PLACE you go, and the day is a STATE the machine is in. States belong in the line it already prints along the bottom of the glass, so the footer says DEBRIEF IN 32M, or THE DAY IS READY, or THE DAY IS SENT - and pressing that line opens the debrief. The menu is back to four rows.

And the report keeps its link. It was always being made - a report plus a seven-day live view - and then thrown at the share sheet and lost behind a toast, so an hour later there was no way to paste it again without writing the day twice. The finished address now sits on the debrief with COPY beside it until the next one replaces it.

SEND THE DAY left the menu, because sending is a button on the debrief now and the row beside it was the leftover. The row is THE DAY, it opens the debrief itself, and it carries the countdown as its value - which is also why he could not see the debrief timer. It was an eleven-pixel ring at the end of a hairline strip that only existed on days he had already shot something. A menu row that reads 32M, READY or SENT is a thing you cannot miss.

And the Dex is ONE page. A roster plus an entry plus a status page was three screens pretending to be a book; the real thing was never paged - from Gen IV on it is one screen with the highlighted specimen on top and the whole collection scrolling under it. Moving the cursor changes the top instantly.

The other half of that complaint was the important one, and it was our fault: he said he does not even know what the app collects. So the plate now prints EVERY kind we hold - photos, walks, clips, papers, notes, measures - zeroes included, because a kind reading 0 tells him the tool exists and this job has not used it. Plus ground, days, owed, first seen, last worked, and ten weeks of days as a strip. A on a row stands you on that job.

The chassis key now steps aside while the lens holds the glass. It keeps its place in the layout so the face does not jump; it simply stops being a control until the lens closes.

And A finally says what it does. The key already retargeted to whatever is on the glass — the silkscreen just never mentioned it. Now the legend reads SHOOT instead of GO while a viewfinder is up, in every mode, and goes back to GO when it is a menu again. One word, printed only when the meaning changes.

The rule underneath, in Kymani's words: their device is the emulator. The camera is shown THROUGH the machine's own screen, never thrown full-bleed over it — a black sheet across the pad is the old app coming back through a door.

The inset lives on the device frame itself now, where nothing can carry it away again.

And the menu stacks from the top instead of distributing evenly down the glass. Filling the frame was right; spreading five rows across a tall phone with 130px gaps between them was not - a handheld menu is a list, not a layout.

So the place goes and the capability moves onto something he already does daily. A line you owe is not a different object from a note - it is a note in the FUTURE TENSE. NOTE now carries one switch: off, the words are pinned to a day that happened; on, the same words are owed by that day. Same sheet, same date field, one flag.

The things you owe come back where they already did: on the job plate when you are standing on it, on the job own screen, and on the debrief when the day closes. YOU SAID moved onto the debrief with them, which is where a promise lifted out of your own notes was always going to land best - at the end of the day, before you drive off.

The menu is a row shorter and the composer, its five decisions and its dead state are deleted rather than left lying around.

The mistake was thinking a dex is about ONE of them. It is not - it is the SET: everything caught, numbered, and sortable, which is the only reason anyone ever opened it. So the Dex is the ROSTER now. Every job on one page and the pad turns the ruler: NUMBER, OWED, QUIET, HELD. The right-hand figure is always the one you sorted by, so the list answers the question instead of making you do the arithmetic.

QUIET is the one that earns its keep. Nothing else in the machine tells you which ground has gone cold, because the jobs you forget are exactly the ones you never open.

The entry keeps only what neither the roster nor PLAY can hold: the job LIFE, ten weeks of days as a strip, so you see the shape of it - a burst in July, silence since, back on it today.

The cartridge went inside the machine. The shell above the lip was the most honest object here and it cost the device its full-screen silhouette, so the shell is inserted where a shell belongs and its LABEL rides the top of the glass - fourteen pixels inside instead of sixty-five outside. The debrief ring moved there too, visible all afternoon now instead of for one 45-minute window, and pressing it opens the debrief instead of waiting for it.

PLAY plays four verbs with no escape hatch, the way Gen I did (FIGHT/PkMn/ITEM/RUN had no MORE): CAMERA, NOTE, FILE, ASK. A MORE is an admission the four were not chosen, and nobody opens a drawer. The job own tools moved onto its plate at the top of the encounter, where you were already looking.

And the face picker is hooked up. The cover always preferred the sharpest frame sliced out of the 360 walk, which is exactly why a job face was a fisheye. Now it prefers a frame a PERSON framed, then one he wrote a note on, then one whose subject recurs across that job - the thing you photograph over and over IS the job. Fisheye and 360 frames are disqualified outright. It costs nothing: every photo was already read once, and this is arithmetic on words we already hold.

The shift now paints INSIDE the glass, in the machine's own light: the LCD faceplate and tint it is actually set to, headings in the same pixel typeface the device writes in, and the hardware keys doing the work — A is always the verb the screen is asking for, B always steps back, the same contract the camera already keeps.

On the clock, the eye takes the whole screen with the running time riding on top of it, and the deliverable runs underneath as a filmstrip. Same component, same clock-in, same reel — only the chrome changes, so there is never a second way to hire someone.

Two things the screenshots caught that no typecheck would have: a missing thumbnail was printing its own alt text as words in the filmstrip, and a shift that reached the live screen without a start stamp printed the seconds since 1970 as its clock. Both fixed; both would have shown up in a field test as 'why does it look broken'.

He is right, and the dial that landed hours earlier is exactly where it belongs. SPLAT is now a camera mode beside PHOTO, VIDEO, WALK 360, PANEL and PART. Turn to it, press the shutter, record, keep — and the clip goes to the box in the same motion that files it. No list, no second decision, nothing to find later.

The seam is a capture id, not a URL. The recorder finishes holding the id of the row it just banked, and the server looks up where the bytes live — the camera never has to know how storage is addressed.

The upload door stays open for footage shot on something else, and that is the only place a list of clips belongs.

What it does not need: capture technique. The proof clip was shot one-handed from a boom lift while installing a camera on a pole, no orbit, one side only. What it does need is MOVEMENT — the camera has to travel, not pivot. Standing still and panning gives no parallax and reconstructs nothing.

So the shutter is the only door, and inside it there is a mode dial, the arrangement every real camera settled on decades ago. The D-pad turns PHOTO / VIDEO / WALK 360 / PANEL / PART and A fires whichever is under the mark. PHOTO shoots where it stands; the others hand off to the tool that owns them and close the lens behind you.

PLAY plays four commands now instead of a list of lenses: SHOOT, NOTE, THE FILE, MORE. The camera tools are not gone, they moved inside the thing they all needed anyway.

It stays honest about cost and speed. Every primary road in his region is 13 MB and eighteen thousand ways (measured); motorway and trunk simplified at map scale is a few hundred ways and about 75 KB, which a phone draws without noticing. At a region's zoom a kilometre is roughly four pixels, so a kilometre of tolerance discards nothing the eye could have caught. One fetch per region, EVER: the bbox is rounded so a wobbling fix still hits the same key, the edge holds it a month, and the phone keeps its own copy after that. The map draws its pins first and lets the land arrive underneath — it never waits.

A bug worth naming: the first cut returned an empty answer WITH the month-long cache header, so a single Overpass hiccup would have frozen a blank region into the edge and onto the phone until September. A failure is never cached now, and the route takes one patient retry before giving up.

AND THE MAP STOPS MOVING. Kymani: “the lighter part of the map where the points sit, when moving between points fix this — it changed once when the card said ohhhh it is your here location.” Exactly that: the frame was built from the sites PLUS the phone's own fix, so the moment GPS landed or drifted the whole region rescaled and every pin jumped under his thumb. The frame is built from the SITES ALONE now — they do not move, so neither does the map. YOU are simply drawn onto it, and left off honestly when you are standing outside the region rather than clamped to an edge you are not on.

The dotted stand-in routes between neighbouring sites are gone with this. They were scaffolding for a map with no land in it; against real highways they were a second web of invented lines competing with the true one.

The Dex entry became the real pair of pages. ENTRY: the sprite standing, the number, the name, the town as its species line, then GROUND (how far the worked spots actually reach, printed in feet or miles), HELD and WORKED - and a caption assembled from dates, never written. STATUS: the party page, a CLR bar and four counts hard right. The pad flips between them the way the original flips, and nothing on either page loads.

And the debrief stopped being invisible. A small ring beside the head count fills across the forty-five minutes since the last thing landed; inside the final ten it turns into numerals. Silent for thirty-five minutes, unmissable for the last ten, and it is the same clock the card fires on rather than a second opinion about it.

So a shift now eats its own scaffolding. A walk's chunks are its retry source and still survive untouched, but a worker's deliverable is the photographs it already banked — the chunks are only the transport. Each one is dropped once its frames are read, keeping a one-minute tail in case of a hiccup. Peak cost per shift falls from hours-of-footage to about sixty megabytes.

The watchman also learned the difference between the scene moving and the CAMERA moving. Measured: a person six metres out changes 1% of the frame, a bumped tripod 46%, a hand-held camera 62%. Anything past 35% is the camera, not an intruder — so it is not an event at all. Without that, picking your own camera up files a report on yourself, and a camera left swinging buries the real event under one endless false one. The shift now says plainly that the camera moved instead of lying about it.

All four trades were then replayed through the real box against real recorded footage — no camera, no phone, jobs attached to no card. The watchman found exactly one intruder in four hundred noisy parked frames and zero false alarms, and reported the same footage shot hand-held as a quiet shift with nothing moved. The replay earned its keep twice: it caught a Windows file-lock that killed an entire shift over a piece of housekeeping, and it caught the timekeeper overwriting its own visit log with the number of visits — destroying the one thing it exists to produce.

So the paragraph is gone, along with the model call and the spinner. The caption is now assembled from dates the record already holds, in a fixed shape, the same every time: when you first stood on it, when you last worked it, what is still owed. Instant, free, and impossible to be wrong about.

The full entry format is being picked from mocks of the real Gen-I layouts. This part just could not stay shipped: a spinner and a charge on every job you glance at.

SUPER and LOADOUT fail that test — no eyes, done in seconds. Both came off the page. Neither was deleted: SUPER already lived on the Tradesboy glass and the world's day bar, and LOADOUT moved to SHARE with the other documents the record writes (it was the only door to that feature, so it moved rather than died).

Three new employees clock in beside the photographer. THE WATCHMAN: park it where it sees your tools and it watches all 360°, banking whatever moves and when — a quiet night is the good outcome, not a failure. THE WITNESS: point it at the pour or the pressure test; it keeps a steady beat and is forbidden to curate, because the moment that matters is the one you're proving, not the prettiest one. THE TIMEKEEPER: stand it where it sees the way in and it logs every arrival and how long they stayed — the backup sheet for the manpower argument.

They are one rig, not four scripts: the same clock-in screen, the same live eye, the same reel. What differs is the question each holds open and one conditional over the feed. Hiring the next trade is a table entry.

The watchman's motion detector was measured, not guessed — replayed against real X5 relay frames it scores a true zero on a parked camera in daylight, at night on a noisy sensor, and through a dusk that drifts, then fires with 2.5x margin on a person six metres out. It cannot cry wolf at grain, which is the only thing that makes a night shift worth trusting.

So the photoreal map is OUT of the pad, and what replaced it is what a Pokemon map has always been. THE WHOLE REGION AT ONCE: every site standing at its real place, so the spread of the work IS the picture. DRAWN, NOT STREAMED: pure SVG from coordinates already in hand, on the glass the instant the screen opens — no key, no tiles, no cost, works offline and in dev where the Google key never did. ONE TOWN NAMED at a time, under the cursor, because fifteen names on a phone is the sticker bomb he threw the first map out for.

The paragraph is gone too. The name, how far it is, what stands there — and then at most ONE line, printed only when it would change what you do today: a storm, a conductor close enough to matter, or the light running out. Everything else the ground route knows is still there, still cheap, and no longer standing between him and his map. The facts are now fetched a beat AFTER the map is already up, so riffling through fifteen towns fires no requests at all.

The lenses went with it. Four became three became one honest state: every direction on the D-pad now walks the region.

It carries a surveyor's graticule, dotted routes joining each town to its nearest neighbour (the shape of the territory, not a drive route, and it does not pretend to be one), a measured scale bar, north, YOU in green where the phone says you are, and a dot on any site that still owes you something.

It costs nothing until pressed. Every fact on the card is already in memory - no query - and the read only calls the model if you ask for it.

And tasks became THE LIST. The unit was wrong: to write one thought down you had to tap New Task, type it, cycle a site picker, pick a date and press Add - five decisions for a sentence, which is why the sentence went in a note instead, or nowhere. The line is always sitting there now, Enter files it to whatever cartridge is loaded, and the job and the date only appear once you have written something worth refining. The word task went with it; nobody in the trade says task.

The framed window fills the glass instead of floating in the middle of it. The window is the grammar and stays - a handheld lists things inside a window - but the floating cost a third of the height on the busiest screen in the machine.

Every job now has a FACE. Its own newest frame, posterised to four tones and blown up to chunky pixels, so the roster is three recognisable jobsites instead of three identical lines of type. Done with an SVG filter, no compute, out of the photos already shot. A job with no photograph yet wears a pixel monogram - the letter idea, kept for the one place it is the right answer.

And the Dex opens into an ENTRY instead of a tool screen: the number, the name, the job standing on its ground, what it is made of (photos, walks, clips, papers - never a kind it does not hold), its numbers, and two or three sentences the machine writes out of the record describing what this job IS. Written once and kept beside the job, so flicking through the Dex costs nothing. A still walks you onto the job from there.

So the encounter holds the day. The job stands opposite you with its level and its bar; between you is TODAY - the scope in your own words, what is due on THIS job, and the machine read of the record - and the command window under it asks what you will do about it.

Nothing was lost in the fold. The scope writer and its photographs, the day facts and THE READ all moved into the band. The rest of TODAY was already somewhere else: shoot-it-now is the PHOTO command and the shutter key, GO TO WORK is the cartridge shelf, and ASK lives on the job own screen. The menu is one row shorter.

And it stopped being a list. The record is mostly photographs and it was rendering them as 38px stamps beside a line of text. It is a CONTACT SHEET now: day bands, and under each a grid of frames big enough to recognise the panel you shot. Every frame still wears its own note underneath, and says no note honestly when there is none.

Video was completely dead in there. A clip rendered as the word CLIP and did nothing when you pressed it - the mp4 was sitting in the row the whole time. Clips now show their own first frame (the browser makes the thumbnail, never the CDN, and the mp4 still never enters an image pipe) and play on the glass when tapped.

A is the shutter. With the machine firing the camera, the on-glass controls stopped needing a row of their own - they float over the frame on a scrim, so the viewfinder is the entire screen. A shoots, then A again is USE. B drops the frame you are reviewing, and only then does B leave the camera.

VIDEO (150), WALK 360 (80/200) and the X5 link form (200) were dead the exact same way. Four tools, one cause. Nothing in the code said which numbers sat above the device, so nothing caught it - so the whole stack now lives in one file, pwa/lib/z.ts, with a comment on every rung saying what it has to clear.

And the camera changed shape. A full-screen black sheet thrown over the pad is the old app coming back through a door. On this machine the glass IS the screen, so the viewfinder now paints inside the projection: site name across the top, shutter at the foot, B backs out of it. Same camera underneath - one sensor, one review beat, one upload path - just painted in the device instead of over it.

THE LENS NAME COMES DOWN OFF THE LAND. It was 8 px of type over a photograph — invisible on a real phone, which is why flipping felt like nothing happened. It is a strip under the map now: ▲ YOUR DAY ▼ with the ring beside it, in a box, at a size you can read at arm's length — and the strip is tappable, so a thumb on the glass can walk the lenses without reaching for the pad. Verified switching: YOUR DAY's green marks give way to THE WIRE's poles and conductor, name and ring moving with them.

THE MAP MOVES WHEN IT ARRIVES. It always panned — after five seconds of stillness, which on a map you glance at for three is never. The pad's own window starts drifting after nine tenths of a second; the bigger card views keep the longer, calmer wait.

THE GROUND IS REMEMBERED, AND THAT IS THE COST CONTROL. Nothing in the placard is about the PERSON — it is entirely about a patch of earth — so marking it `private` was throwing every hit in the bin. It is public now, keyed by its own coordinates, an hour at the edge with a week of stale-while-revalidate: the second tradesman to stand on that ground pays nothing and neither do we. Under that sits a disk cache on the phone, so the second time the app opens on that ground the placard is simply already there. The fastest request is the one never made.

THE MASTHEAD SHARES ITS ROW. Three keys were absolutely positioned over a centred wordmark, so on a real phone they collided. The row is a flexbox with a spacer the same weight as the keys — the wordmark stays centred, the keys own their ground, and the type shrinks before anything can overlap again. Checked at 393 px, his phone's width.

The command window at the foot asks WHAT WILL YOU DO and gives you the four moves a jobsite actually takes: PHOTO, WALK 360, NOTE, MORE. The D-pad walks them, A fires. No menus, no scrolling, no reading.

Why: the day should open on the thing you are facing, not a list of things you could open. A jobsite is an opponent - it has a level, it has a bar, and you spend the day knocking it down.

Also fixed: a visual-verification harness leaked onto main in an earlier commit and was serving three fake sites to every local dev run. Production was never affected (it was gated to non-production), but the harness is gone.

The submit endpoint has two inserts: one for a LIVE walk that opens a job at START, and one for a finished video. The phone-video flag was written into the first one. A clip never takes that branch, so the flag was set on a code path a clip cannot reach, and every clip arrived at the box carrying no instruction at all.

The worker then did exactly the right thing with what it was given: no source, so treat it as footage. A silent, correct-looking failure, which is the worst kind.

Moved to the insert a videoUrl actually takes. The lesson worth keeping: when a file has two inserts that look alike, a first-match edit will find the wrong one, and the result will not error — it will just quietly do nothing.

THE FACE: a real bitmap font (Silkscreen). No amount of letterspaced Barlow gets there — it is the loudest tell in the room. Labels, headers and stat rows only; field notes stay in a face you can read a paragraph of in the sun.

THE WINDOW: a Pokémon menu is a box with a heavy border and a rivet in each corner, drawn from a tile set. The menu and the dex now sit inside one.

THE CURSOR: solid, black, on the left of the chosen line — and it does NOT blink; it simply sits where you are. And the dex row took the shape of a party screen: number, NAME, then level and an HP-style bar hard right, drawn with a hard outline and a solid fill, no rounding.

PLAY now drops you straight on the loaded job’s moves, and the menu row says which job that is. TODAY is its own quiet room next door — the scope, what’s due, the read. Neither screen has two jobs.

YOU SAID moved in with TASKS, where a promise belongs. His instinct was right too: features that aren’t a tool or something you can see shouldn’t take the front of the day.

And a DEX entry finally says something: a number, the name in caps, what the site actually holds (41P · 3W · 8D), what it owes, whether it was worked today, and a level bar you can read across a room.

The diagnosis is DOUBLE ENTRY. The natural act in the field is typing a note where you stand. Filing a second, separate task about the same sentence is homework, so it never happens — and the commitment dies inside a note nobody re-reads.

So the machine reads his own words back. A YOU SAID block sits at the top of the day holding the promises hiding in recent notes — in HIS phrasing, never rewritten into task-speak, each naming the site it came from. KEEP turns one into a task carrying the id of the note it came from, so it never asks twice; ✕ means it was never a reminder and it stays quiet forever.

Nothing new gets typed. Tasks stop being data entry and become confirmations.

COLMAP registered 52 of its 57 frames at 0.72 pixels of reprojection error, first try. Perspective frames with real intrinsics are simply an easier problem than blind-posed fisheye, and every piece of the chain was already sitting on the shop box.

So there is a SPLAT tool now. Open a job, pick a clip, and the box builds it: frames, camera solve, gaussians, levelled, published. It keeps running whether or not the app stays open.

Two guards are baked in because both nearly cost us the result. COLMAP writes MORE THAN ONE model — it produced a four-image fragment beside the real 52-image solve, and everything downstream reads the first one by convention, so the good reconstruction was one command from the bin. And COLMAP has no idea which way is down: a model straight out of it hangs at whatever angle the first camera held, which is why the first one had to be viewed with a bent neck. Both are now handled before a human ever sees the result.

The levelling carries the rotation into the gaussians themselves, not just their positions. Turn only the centres and every disc keeps facing its old direction — surfaces smear into streaks.

That absence cost two things, and both showed up tonight. A solve had to GUESS which way is down by searching hundreds of directions for whichever plane held the most points — a decent trick, and completely unnecessary on a device holding an accelerometer. And scale could not be recovered at all: a parking lot came back reporting 147 metres across, because structure-from-motion has no units.

Now the tracker starts with REC and stops with STOP, and the JSONL track uploads beside the clip while the review beat is being read — by the time you press KEEP it is usually already there. The clip's row carries track.url, its sample count, and the wall clock the poses are stamped against, which is the only thing that can line a pose up with a video frame afterwards.

Best-effort in every direction: no plugin (any browser), no ARCore, or a failed upload all leave the clip exactly as it was. A track is a bonus, never a gate — same law the X5 path already used.

What this unlocks is not a new feature, it's a shape: a clip with poses IS a bundle, and a bundle is what the one genuinely good model on this box was built from — 126 keyframes, feed-forward net, Brush, 168 seconds, upright, with a ceiling correctly measured at 2.56 m off the result.

Meanwhile HISTORY, on the same glass, already grouped by day, printed the time, named the site, and showed a thumbnail. Same data, two completely different qualities of answer, and the worse one was the one wearing a modal.

So the drawer is rebuilt in the machine's own grammar: day headers (TODAY / YESTERDAY / 8/24), a real thumbnail for every photo, a poster frame for every clip pulled by the browser itself at metadata-only cost, the kind in its own ink, the time it landed, and a two-tap delete that arms before it bites.

ADD FILES is now a row at the top of that list rather than a button on a sheet. It still calls the one upload door — the OS file picker is the only part of this allowed to be somebody else's interface.

The rule this leaves behind: if a surface shows a file, it shows the file. A list of the word 'Photo' repeated is a database dump, not a record.

The bigger one came out of screenshots. Rows that aren't selected were drawn at 0.70–0.72 alpha, which is thin ink on a cream screen before you add sunlight, dust, or a fading screen transition. In the shots the unselected rows read as ghosts while the selected row and the orange stayed solid — it looked like a colour that changed and never changed back.

The floor is raised: unselected rows now sit at 0.9, and the selected row uses the glass's full ink rather than a slightly brighter version of the dim one. Contrast no longer depends on which row the cursor is parked on.

This machine gets read outdoors, in sun, through dust, with gloves on. Anything under about 0.85 ink on the cream skin is decoration, not text.

The word beside the lamp was the easier call: a lamp already IS the sentence. Lit means someone is working. Printing the word sideways next to it says the same thing twice, in the least readable orientation on the device, in a place the eye never goes.

The status strip is the more useful lesson. It had been rewritten twice trying to find words worth putting there — first SPACE · TIME · MEMORY, then WORKER ON THE CLOCK / ALL CLEAR — and both times the words were blamed. The words were never the problem. The PLACE was. A bezel is the moulding that makes glass look set into a machine; nobody reads moulding, and dynamic text there is doubly wasted because it changes where nobody is looking.

Live facts belong on the glass, where the eye already is. What is left is bezel: a hair of height so the surround still frames the screen, and silence.

Checked while in here, because it was raised as a worry: the work light cannot be left on. It dies on visibilitychange when the app is hidden, on pagehide when it closes, and on unmount. Three guards, already in place.

A CHAMFER: a real moulded cross has a cut edge catching light the whole way round its outline; ours had a gradient painted on a flat shape. Two clipped layers now — a bright rim beneath, the face inset on top.

ARROWS: every Game Boy pad has direction marks pressed into the arms, and ours had none, which is why it kept reading as a shape instead of a control.

That rule killed two of my own four lenses. THE PAPER and THE COUNTER were printed lists wearing a map's clothes; the permits and the counter already had placard lines, so the lists are gone. Three lenses remain and each is a genuine way of LOOKING at ground: YOUR DAY (default), THE WIRE, FROM THE ROAD.

His other question — per-site or global? — is answered by the scope that makes the sticker bomb impossible: ONE SITE, ONE DAY. The map carries the newest day you actually worked there, never the whole history. A day is a handful of captures by nature, and the global record already has its homes in the world and the daybook. On top of that: marks merged within about fifty feet (twelve photos of one panel is one place you stood), a hard cap of fourteen, and no type on the land at all. Tested with a real 22-capture day: it drew seven quiet green marks.

The ledger behind it is the daybook's own route, now carrying coordinates and taking an optional siteId — the same query, one filter, never a second implementation. It is bounded: if the record has not answered in three and a half seconds the map opens without the marks rather than showing nothing.

THE WORK LIGHT. A real key on the chassis beside the globe — the phone's torch, because the moment you need it your other hand is holding a panel cover. There is no web API for a flashlight; it is a constraint on a live camera track, so the app owns exactly one track and gives it back on every path out, including the moment the app is backgrounded. A light left burning in a pocket is a battery gone by lunch.

Deliberately NOT built, and this is a judgement rather than an omission: buried utilities. Overhead power is safe to draw because you can look up and confirm it. Buried gas and water cannot be confirmed, the open data is thin and stale, and the law is that you call 811 and have it marked. A map that draws an approximate gas line beside a trench is the one feature here that could kill somebody. The 811 line itself was also left off the placard — it would evict a measured fact for a sentence every tradesman already knows.

Every key on the face is now moulded from the same plastic under the same 168° light: the same rim light on top, the same dark under-edge, the same contact shadow, and the same sink when a thumb holds it. A/B stopped being glass marbles and became domes that match the shutter; the pills got real cylindrical relief; the grill slots are cut into the shell instead of drawn on it.

And he was right to question the box: no Game Boy has a rectangular plate around its cross. It sits in a shallow ROUND dish cut into the shell, and now so does ours — barely darker than the plastic around it, the same dish the A/B pair sits in.

THE TINT IS THE OPERATOR’S CALL. The matrix does most of the work of saying “screen”; the colour does the rest and carries all of the cost — and this machine gets read outdoors, in sun, through dust, with gloves on. NEUTRAL ships as the default (full contrast, and less borrowed than everyone else’s pea-green), with the DMG olive and a plasma amber one tap away in Settings.

THE ONE-KEY LAW: the Tradesboy gets exactly one key beyond the Game Boy set, forever, and it is the SHUTTER. Nintendo shipped a camera cartridge; a Game Boy with a camera in it has a shutter. Ours is loaded with a jobsite. Any future feature earns a place on the glass or it does not exist.

So the screen is an LCD now. It is TINTED and never goes paper-white, and it carries a real pixel MATRIX — two hairline grids across it, the one detail that stops a panel reading as a sheet of paper.

The menu stopped being a nav: condensed caps, hairline rules between rows, a blinking cursor on the selection, counts set as instrument print. Tighter margins, no padded card. Same information, half the furniture.

The right pill is now HISTORY. It opens the owner-only ledger the daybook reads — every capture on every project, placed or not, photographed or typed, plus every walk — newest first, grouped by the phone’s own calendar day. Each day’s header counts the entries and the sites they came from, so a four-site day says so on its face.

A photo opens on the glass with its note; a walk opens its footage. Nothing new was stored to build this — it is one more lens on the record that already exists.

The mobile corrections are the deliberate departures: a THIN bezel (a real DMG spends half its face on plastic; the glass grew to 56%), every control in the lower thumb arc, nothing under 44px, and one key a Game Boy never had — the SHUTTER, fixed to the camera, because a photo is the commonest move in the trade.

The map now wears FOUR LENSES and the pad's own D-pad walks them — left and right still walks your sites, up and down changes what the land is showing. No menu, no buttons, two axes: THE WIRE (poles, transformers and conductor standing in the 3D site), THE PAPER (the block's last electrical permits in the county's own words — “Replace Service Entrance Cable”, “150 amp SEC replacement only”), THE COUNTER (the nearest supply houses with distance, electrical ones first, and a real drive time on the closest), and FROM THE ROAD (Street View of the address — what the place actually looks like before you drive out).

Two things were designed wrong on the first pass and got rebuilt rather than shipped: the counters were going to be pins, until measuring showed the nearest is 2.4 miles out and the rest run to 9 — nothing a 500 m window can hold; and the permits were pins too, until sixteen of the twenty on that block turned out to share one address and drew a single grey dot. Both PRINT now. A thing whose worth is its words should not be a dot.

Under the hood the whole OpenStreetMap side is ONE round trip — wire and counters together — because Overpass allows two slots per IP and spending two calls where one does is how a card starts failing under a crew. Measured and tuned: the merged query runs ~4.5s at an 8 km counter radius and 7.7s at 12 km, which blew the budget and took the poles down with it. 8 km returns the same counters.

Every lens's geometry is built once when the world mounts and simply shown or hidden per frame — flipping a lens must never reload the tileset, which would both flash and bill.

THE WIRE IS ON THE LAND. Every mapped pole now stands at its real spot in the 3D site, transformer cans on the ones that carry them, and the conductor strung between them — distribution in amber, transmission burning orange, because voltage is the thing that changes how far away you have to stand. 95 poles and 26 spans around the Rockville card, straight from OpenStreetMap.

THE CLEARANCE LINE. The nearest mapped conductor is named with its voltage and distance, and the legal minimum approach read off OSHA 1926.1408 Table A — looked up in the regulation itself, not recalled from memory, because a wrong number there is somebody's life: up to 50 kV is 10 ft, 50–200 kV is 15 ft, and 20 ft until the utility confirms the voltage. The card only ever speaks about a conductor it can actually see; silence is not a clear site and it never claims to be one.

THE ROOF IN DOLLARS. Google's Solar model gives this roof's yearly output; the utility layer gives this utility's own rate. Together: “Roof holds 122.8 kW — about $26,847 a year of power.” Google's own modelled number with the standard DC→AC haircut, not capacity times sunshine hours dressed up as a forecast.

An hour was lost to one thing worth writing down: the world's seat() puts an object in the TILESET's own ellipsoid frame, whose Y sits at planetary scale (-4,832,948 while the camera flies at y≈200). Everything else that gets seated quietly overwrites Y afterwards and nothing said so out loud, so the grid was built, added, seated — and vanished 4,800 km under the floor. Seat gives X and Z. Never Y.

THE CAMERA IS NOW A KEY ON THE MACHINE: a fire shutter, bottom-centre of the pad, always visible, shooting straight to whatever cartridge is loaded, from any screen. Long-press changes what it fires.

And TAKE A PHOTO is the first row on the day’s screen, naming the job it will land on. Two ways to reach the commonest move in the trade, both of them obvious.

Also: the speaker grill lies at the same angle as the keys instead of fighting them, with a QUIET/ON switch beside it that really does silence the machine’s feedback. And the day’s cards stopped being squeezed by flex — the scope’s photo buttons were spilling onto the row below.

THE READ. Under the day’s facts, a line the machine writes itself: it reads ten days of the record and says what it MEANS — what only you can move, what is blocked on somebody else so you don’t drive there, what is slipping. Four sentences, dead plain, and it never invents a fact the record does not hold.

THE SHOP WINDOW. /tradesboy is the real machine, seeded and running, that anyone can pick up in a browser — not screenshots of the product but the product.

THE PERMIT SCOPE WAS BEING THROWN AWAY. Nearly every Montgomery County row opens with the inspection notice, and the real description is glued onto the end of it with no space — “…permit issuance.Lighting energy efficiency project for Montgomery County Public Schools. All one for one fixture replacement.” The first cut rejected any row starting with the notice, which discarded the best sentences on the card. It strips the notice now and keeps what follows.

THE PERMIT QUERY WAS BLOWING THE BUDGET. A cold sorted query at limit 50 takes 5.4 seconds and died every time inside the parallel fan-out; at limit 20 it answers in 180ms cold. Also killed the row count: the window is capped, so any number printed would have been a cap dressed as a census. The line names WHAT was last pulled on the block and WHEN.

OVERPASS 406s AN ANONYMOUS CLIENT — and this is the one that matters beyond the map. OpenStreetMap's server returns a bare 406 Not Acceptable when a request carries no User-Agent. curl sends one, so every hand-test passed; Node's fetch sends none, so every server-side call this app makes was failing, and failing SOFT. That means SOURCE's “counters near you with their phone numbers” and the building-footprints layer have been quietly returning empty in production this whole time. One header fixes all three routes.

Also dropped the 16 km substation sweep: it cost more than the whole query's budget and fed a line that almost never printed, because the utility layer names who owns the power far more reliably.

The globe key no longer throws the whole earth up over the machine. It opens a TOWN MAP on the glass: the land in the pad's own window, your sites walked like towns with the D-pad (the ring wraps, and it opens on the one you're nearest), A to walk into a town, B out. Press the globe again while standing on the map and the full world still comes up — one key, two depths. The land is the app's one world implementation wearing a new `bare` dress: no on-screen keys, no printed D-pad, because the machine already has one on the case.

Under the land is the PLACARD — what this ground IS, in six sentences, hardest first, with nothing to press. Every fact was probed live before it was trusted: light left until sunset (computed, never fails), temperature and wind, an active National Weather Service alert if one is running, the flood zone but only when it's a real hazard zone that drives where service gear sits, WHO OWNS THE POWER and what a kWh costs here, the last electrical permit actually pulled on this block in the county's own words, the NEC edition in force, poles and transformers on the block, and what the roof holds in panels.

What the probing found, so nobody re-walks it: our Google key is referrer-locked to production, so every call is made server-side with the allowed Referer injected — the same door the geocoder already uses — which is why this works in dev and inside the APK. Solar, Weather, Places, Routes, Roads, Address Validation and Air Quality are all live on that key; the legacy web services (Geocoding, Elevation, Directions, Time Zone) categorically refuse a referrer-restricted key and are dead to us. HIFLD, which every tutorial still recommends for utility territories, was deactivated in August 2025 and its URL 400s; Esri's Living Atlas rates layer replaced it and was checked against four DMV points. There is no lawful free power-outage feed — that layer was not built rather than scraped. NEC adoption has no machine-readable source, so it's a small hand-kept table that says out loud to check local amendments, and DC is deliberately absent because its edition couldn't be pinned to a primary source.

Montgomery County's permit data is the star and it is county-scoped: outside those bounds the line simply doesn't print. It never says “no permits” when the truth is “no data here”.

The content stopped floating. The entire phone is one body: a cartridge seated in the top edge, the masthead, the screen set in a black surround, the controls below. Nothing hovers above anything.

THE CARTRIDGE ANSWERS THE FIRST QUESTION. Kymani spotted why it works before I did — it sits in the black band where the phone already keeps its camera, so it reads as hardware. It names what the machine is LOADED with: the ground you are standing on, and how many sites are in reach.

And the strip that read SPACE · TIME · MEMORY is gone — "I don’t even know what those are for." Fair. In its place the machine says what it is DOING: the lamp and the words are the same fact, WORKER ON THE CLOCK or STANDING BY, with what you owe on the right.

The right pill is the QUICK KEY: one move of the operator’s choosing under the right thumb, Photo by default. Long-press it (or open Settings) to cycle: Photo, Walk 360, Note, Measure, Ask.

And the world stopped being a hardware pill — it is a small globe key beside the colorway toggle, since it is a place you choose to look at, not a verb you press all day.

A camera button sits beside the + on every task and on the day’s scope — it opens the LENS, not the gallery, because most of the time the permit is in your hand and the install is in front of you.

And nothing you type is a commitment: tap a task’s words to rewrite them. The checkbox is still the only thing that closes it, and pressing it again reopens it.

THE THUMB IS ANSWERED. The cross leans into whichever arm you hold, the fire buttons sink and flare, the WORLD and RECORD pills depress — with the haptic tick on every press.

THE PROJECTION IS LIT FROM BELOW: a warm bloom rising off the pad, so the content reads as light coming out of the machine.

THE PAD IS AN OBJECT: an extruded wall built from stacked shadows that follow its own curve, a milled chamfer ring, and a few degrees of lean so it SITS on the ground.

And the part that was quietly wrong: a finished task used to vanish. Now closing one moves it to a dimmed, struck-through TRAIL you can reopen with a tap; the only way anything leaves is a deliberate two-tap DELETE. Photos attach to a task AND to the day’s scope — the panel to come back to, the marked-up drawing you were handed this morning — and ASK reads the scope with the rest of the record.

Top of the screen is THE SCOPE — one sentence in his own words about what the day is for ("finish Redland, call MC311, lift at 10"), written straight onto the glass and pinned to the date. Under it, a briefing the record writes by itself: what’s due today, which sites have been worked, whether a worker is on the clock. Then the due items, tickable where they sit, the sites to walk into, and ASK for whatever the brief missed.

A mission is its own kind of record row (kind=mission) — deliberately not a day note, because a note is what happened and a mission is what the day is FOR. Keeping them apart means the timeline never fills with plans and the plan never gets lost among photos.

The wordmark drops below that line and grows — TRADESMAN big and left-set, the fire dash, REALITY PAD in small caps — the exact hierarchy the DMG uses. The bottom-right sweep opens up so the silhouette reads harder from across a room.

A and B keep their retro letters, but the plate is silkscreened with where they go: LEFT-B-BACK, GO-A-RIGHT. Fun stays, confusion goes.

CREW is now WORKERS (it sounds like the game it is). LEAGUE is now TASKS — it was too bound to one contract; this holds anything he manages, on any ground: call off a lift, meet an inspector, close a permit. And it finally has the half that was missing: you can ADD one from the glass, with a site chip and an optional date, then tap it closed.

The card surfaces now live ON the glass: TOOLS is the full moves grid (Walk 360, Video, Note, Measure, Upload, Ask, World, Send — every one fires its real sheet over the device). HISTORY is the RECORD screen: photos wearing their notes, day notes, papers and walks day by day, with a viewer on the glass. WORKERS is the crew screen — the photographer clocks in from a site pick. SETTINGS holds the X5 link, the colorway and the build.

Play opens TOOLS, not the map ("play should open to tools" — the daily verb is work); the world lives on the hardware WORLD pill. And dark/light now flips the WHOLE glass — paper screen with ink text in light, night glass in dark — with the toggle moved onto the faceplate.

The first three are REAL migration: they open the exact sheets the card tools open, rising over the device. Capture, note and measure are device-native now. Timeline, Workers and Settings remain one honest row — "on paper, for now" — the shrinking migration list.

The home menu shrinks into the top-left corner — a quiet list, fire tick on the selected row, counts as small numerals. And the dark/light toggle is a visible glyph on the glass now, not a hidden logotype tap.

The app now ALWAYS boots into the device. X is a temporary visit to the engine room (capture, timeline, workers — until each lives on the glass), never a remembered exit.

Long lists on the glass (15 sites) no longer clip their top rows — safe centering.

Everything on the glass is the record: Play is the world, the Dex lists every site (level = days worked, owed items burn orange), a site opens ON the glass — stats, its open items tickable right there, ask, world, send the day. The League is the quest board.

The paper app is the ENGINE ROOM: X on the bezel steps out to the cards for capture, timeline, workers — everything not yet reimplemented on the glass — and the PLAYER key steps back in. Nothing was deleted; the surfaces migrate one at a time, in daylight.

The ratio is 7/12 now and it is LOCKED — the card is never rendered at another shape. When the room is short the card gets smaller whole, down to a readable width floor (280px; the print is cqi-sized, so that is where type stays legible). Below that the pile beneath yields, never the cut.

The twin viewer's floating thumb stick (born under the thumb, invisible at rest) is retired for a D-pad: four held keys in a plus, bottom-left, 56px each, the same chevron as RISE/LOWER so the two clusters read as one instrument. Two keys held = a diagonal, like WASD. It feeds the same moveRef the walk loop already reads.

The D-pad he actually meant was the circle on the card's minimap and the big world (the flyover), not the twin viewer's — that one is a plus of four keys now too: micro (20px) on the card views so it never eats the map, full-size (36px) on the world. Whichever key the thumb is over is the held direction; slide across the plus and it follows. Proven on the loci-lab bed: hold FORWARD and the field slides under you.

Then: "make it Pokemon style with the chevrons pointing out, same colour and style as our map controls." One solid cross now, a chevron on each arm pointing out, in the voice of the keys beside it — the world's pill (near-black ground, paper line and ink) on the big map, the face's micro key (paper, ink line, hard shadow) on the card views. The held arm washes in the ink.

Reference in hand (a GameSir pad — "small, beautiful, spaced between"): the solid plus became four SEPARATE rounded arms with air between them, a small centre dot, tiny filled triangles at the tips pointing out, seated on a round dish. Still the map's own voice on each surface.

The mask is now worn only while the tools list actually overflows (ResizeObserver, measured). On a real phone that is never — the loadout was sized to stand in the face without a scroll — so the phone never enters the bug; short desktop windows keep the dissolve.

Second wall, same night: Kymani confirmed the dead tabs are the SAME tap as the black — the switch fires, the layer paints black, so nothing looks switched. Inside the APK neither card scroller wears a mask-image at all now (Capacitor.isNativePlatform, read after mount), so no Android compositor path can black the card, whatever overflows.

A short window used to guillotine a tool row in half under the foot like a printing error — cropped content dissolves into the stock now instead of slicing.

And the bookmark tab’s top half slid under the dateline strip because the height math reserved 14px for a 26px tab — the arithmetic tells the truth now and the tab always prints whole.

One new row on the card, above the timeline, because what is owed outranks what happened. It prints the count AND the nearest item — the face says "call the inspector" without a tap. Zero open items still prints the row (the no-card-is-different law: show the move, show 0).

Items are captures rows (kind=todo) — the same no-migration pattern as papers and day notes — so ASK answers "what is left at this site?" with no extra machinery. Deliberately absent: stages, assignees, priorities. One primitive; evidence decides if it ever grows.

Open items stay off the client-facing live window and out of the daybook ledger — they are the owner’s forward planning, not the site’s public face and not a day’s work.

Severed: width now comes only from the window’s width. When the room is short, the card renders SHORTER than its 7/11 aspect (a max-height ceiling), the art yields first and the tools face scrolls — the print never shrinks.

Verified at his window size, on a phone (pixel-identical, no regression), and at a brutal 540px-tall stress case where the card still reads.

Only two things could ever retire that record: a pending-scan entry, and a six-hour timeout. A LIVE RELAY walk never writes a pending-scan entry — it streams to a job instead — so for a relay walk there was exactly one escape, and it took six hours.

Worse, the trap closed on itself: the deploy watchdog shipped hours earlier holds updates while an inflight record is fresh. A stale record didn't just loop the capture screen, it muted the deploy that would have fixed it.

The box already knew the answer. The live job's id is now stamped onto the inflight record when the relay opens it, and on launch the app asks: if that walk is done or failed, the record retires itself and the sheet closes. A running walk, a walk with no job id, or no network all leave resurrection exactly as it was — this only removes a record that can be PROVEN spent.

Resurrection is still the default and still correct. An app death mid-recording must come back to the recording screen. What changed is that a walk which already finished is no longer an app death.

Root cause: the deploy watchdog hard-reloads the page the moment a new build lands, and three landed today. The reload destroys every DOM control; the NATIVE preview layer lives outside the WebView, welded to the relay stream, so it kept rendering on top of a page that no longer knew it existed.

Fix one: the watchdog holds its fire while a capture is live — a fresh walk record or a photographer shift on the clock — with hard expiries so a stale marker can never mute deploys.

Fix two: on boot with no walk to resurrect, the app tears down any orphaned native preview layer, guarded so it never cuts a live shift’s stream. A reload is an app-death; a capture finishes first.

Now the eye IS live — the box develops and publishes the newest frame with every relay chunk, and the phone preloads each refresh off-screen and swaps only when the bytes have landed: no flicker, no broken frames, a green pulse and the word LIVE when it's flowing. The relay's five-second chunks are the honest floor of live on this transport, and the eye now sits on it.

The reel tightened to match — picks appear within seconds of their minute closing.

Now every pick is DEVELOPED flat (the same lens math the dense path trusts, one photograph per lens) the moment its minute closes, not at shift end.

And the shift is watchable while it runs: the clock-in screen shows THE WORKER'S EYE — the newest frame, flattened, refreshed every few seconds — and THE REEL, the picks developed so far, growing as the worker works. You hired someone; now you can look over their shoulder.

And the overlap sweep the founder ordered from the field — I cannot properly exit, elements overlap — closed six real conditions: the photo viewer cluster is bounded past the ✕ and wraps; the MODEL viewer no longer buries ‹ BACK (can-block-exit, one z-order); Watch360 SAVE takes the seat below the status pill it was sitting on; the points readout drops below the toggle row it crossed; the flyover chrome rail wraps instead of pushing ALL off the screen; the status pill ellipsizes before it prints across PEOPLE. A blank new-spot file speaks one verb, and everything was measured before it shipped.

And the three starting guidance screens are deleted whole. Nothing explains the app before you can touch it — it opens straight onto your cards, and every page is a tap away, like the native app it's supposed to feel like.

The printed rule row retires the same day it became readable — two navigations is one too many — kept behind display:none so one flag brings it back if the field says otherwise. Built and judged on the visual harness: first render was invisible (the face container clips at its rounded edge — the tabs moved to the card unclipped root), second render stood, and the page-switch was clicked and watched before shipping.

THE RULE IS READABLE AGAIN: the founder called the shrink honestly — you made the text kinda small and mint so you cannot really read it — so the five names sized back up with real ink, measured still fitting on one line at phone width. No symbols: words, as he ruled. And a one-fact-prints-once catch: the WORKERS tab was wearing the board flag count that the ⚑ pill already carries; it counts its own crew now.

And a keycap dignity fix caught in the same frame: two-word names wrap whole now — PART FINDER on two lines, never PART FINDE with an ellipsis. A keycap that cannot say its own name is not a keycap.

And HISTORY answers the founder question — should the history tab just show data? — with ink: the page now opens on THE LATEST, the record three freshest lines printed as data before any door (TODAY · PHOTO — panel room before pull / YESTERDAY · MEASURE — 128 ft along the walked path), drawn from whatever the warm-load already holds. The rows beneath remain the doors into each kind. Daybook and the timeline stay two scopes of one organ — the merge waits until the daybook settles.

Built entirely against the visual harness: the first pass clipped the tab names under their neighbors, and the fix was the real filing-cabinet insight — stack the z-order so TOPS stay visible and tails tuck, exactly how hanging files actually sit. The colored bookmarks keep their reserved seats; a file already marked by one never tabs twice; the file in hand has no tab because it is in your hand.

The law joins the constitution as Law 7b with its corollaries: a face that cannot fit changes its DESIGN, never its overflow; a rule is navigation, not statistics; QUERY seats on TOOLS; sentence-rows become keys. Content surfaces (the full timeline, the world) still scroll — they are the record; the file faces are controls, and controls fit in the hand that holds them.

Verified: before and after screenshots at 390px, overflow measured at zero. The harness (fake payload + auth bypass) was local-only and reverted before commit.

A summoned worker walks the job as it stands — the newest photos, even ground another walk covered — and never moves the standing bookmark. THE RECORD stays salaried (it keeps the board and files the daily; that automation the founder blessed by name). The cover pulse and the ⚑ pill keep telling the shift state; the STAFF page is where the hiring happens.

And the artifact names itself by its true noun: the card foot now reads JOB FILE. Staff you can see, not buttons you press — the piloted-to-initiative ratio made visible on the paper.

Their findings land on the board every flag now carries a SIGNATURE — BY INSPECTOR, BY SAFETY OFFICER, BY THE RECORD — because attribution is the observability: you know the staff exists when the work arrives with a name on it. The board shows LAST PATROL and an ON PATROL beat when it walks; the evening cron patrols before the daily drafts. A clean site returns zero findings, and that is a correct walk.

His law now governs every future hire, in his words: does it allow the tradesman to have auto QOL, or does it add a button. And the job-file naming reaches the product copy — the drawer, the keycaps, the measure sheet now say job file where they said card.

THE RECORD clerk row left the page — the app's own filing is not an employee you hire. The board it keeps is unchanged and lives where it always did, behind the ⚑ pill.

So the record-walking hires — inspector, quality controller, safety officer — are deleted whole: their route, their HIRE buttons, their duty states, their pulse. The WORKERS page now holds what belongs there: the salaried clerk (keeps the board, files the daily) and the camera trades.

The board itself stands — the clerk owns it alone now, and old worker-signed findings fall away on its next filing. The Scout is untouched: it hunts revenue, and it was ordered by name.

Willfit's missing points were its walks: only walks with finished artifacts were listed, so a walk still solving — or one that died solving — vanished from its day. Every walk prints now; the WATCH door appears only when footage exists.

And every site heading in a day's file is a door — tap it and that card comes to the front of the pile, same move as tapping your ground on the world.

It parses ALL the data — placed or not, photographed or typed — the same indexed record QUERY reads. Photos carry their notes beside them, walks carry their WATCH door, and days with nothing say so honestly.

THE FIELD is the record's space axis; the DAYBOOK is its time axis. Two keys, one row, one record.

The glance's keys stand in one clean column down the left edge: ⤢ MAP, then ⏸ PAN, then ◎ YOU. The card-sized view keeps its top-right row.

The slow pan now drifts the card-sized viewer too, with the same ⏸/▶ key riding its top corner; the full screen never drifts — it is driven.

And ◎ YOU: wherever your position is known, one small key flies the camera back to where you are standing — on the glance, the card viewer, and the full world.

A whisper of a marker — a dim green disc, no plate, no pulse — stands where YOU are standing when your phone knows. It only prints on ground the window can actually show.

Two pieces of chrome left the card's viewer for good: the captures·scans caption in the corner (the card's title band already names the site) and the ⋯ menu — the card window is a place to look; FIND and the placing tools live in the full world, QUERY on the card itself.

And the loading beat is the finished shape now: dark screen, a quietly pulsing FINDING THE GROUND…, then the 3D world fades up whole. The old flat map never appears.

The face world stopped being transparent to make that stick — its see-through sky was the only reason the flat print could ghost into view at all. Minis and small tiles keep the flat map; they never mount a world, so it is honestly their map.

FULL is gone from the card's map — the card-sized window is the map; the full screen stays reachable through an answer's proof door. ⤡ CARD takes the freed left seat.

And the readout came off the same day it went on: every one of its numbers already prints somewhere better — the keys carry their counts, the working bubble pulses on the title band. The window carries nothing, as the old law always said.

MapAnything is a ViT-GIANT model and the box has 8 GB. A window of 8 views does not fit. Windows does not fail that — it silently spills the model into system RAM and runs the same maths 50-100x slower, which reads exactly like 'the solver is slow'. Measured on one 4K walk, seconds per NEW view solved: win 8 = 76 s, win 4 = 45 s, win 3 = 12 s. The cliff is between three views and four: three fit on the card, four spill.

So the live and batch solvers now default to a 3-view window with 1 overlap instead of 8 and 3. Nothing about the model, the footage or the walk changed — the same card now solves about six times as much of a walk in the same wall-clock. Chaining accuracy did not suffer: shared-view fit residual measured 1.2-2.1 cm at win 3, against the 6-8 cm this pipeline already documented at win 8.

This is why every cloud has been thin. A 75-second alley walk got ONE window solved before the walk ended — 262k points — and it was never a coverage problem alone: the box could only chew one window per six minutes. At the measured rate it now gets six.

Also measured on the way, and worth writing down: your best footage has never been given to the solver. A dozen walks in storage are the real 3840x1920 X5 stitch (from .insv uploads) — five times the pixels of the 1664x832 the phone relay streams — and every gaussian model to date was built from the relay. Feeding one of those 4K walks produced 2.3 MILLION points from a single window, against 262k for a whole relay walk.

X5_LIVE_WIN and X5_DENSE_WIN remain the knobs. On a bigger card, raise them; re-measure before you do.

And the enlarged view renders sharper: the canvas mounts at a low pixel ratio sized for the glance, and it now re-picks its resolution when the window grows to card size, kicking back to full frame rate at the same moment.

Tapping the map now grows it to CARD size, clearly inset in the card's ink frame — same world, same GL context, so it opens instantly with zero loading. ⤡ CARD shrinks it back; the FULL pill is the labeled door to the whole screen for when you want it.

The static print now bows out three seconds after the living world arrives, so the two maps never show mixed — instant paint kept, ghosting gone.

THE SELF-FILING DAILY: every evening at 6:45, any job file that saw real work today drafts its own daily report — no button pressed, stamped auto so the reader knows the record wrote it on its own initiative. A human-cranked daily always outranks the machine; quiet days draft nothing. The five dead cron pointers from the February era were cleared out with it. This is the axis the product now moves on: less piloting, more initiative — digital employees grow initiative.

Nothing hidden, nothing locked in: what you gave the card you can see, keep, or take back, forever. That completeness is the trust. Deletes ride the existing ownership-scoped endpoints; counts and the card pool update in place.

The shot itself still banks to the card like any photo — a chained tool never steals the capture, it stands behind it.

The plumbing keeps it honest and cheap: one rolling brief row per site holds the flags and the dismissed keys; the pill count rides the normal sites payload with zero extra requests; a once-per-session background sweep re-reads only the four most recently worked cards, and the route returns its cache untouched whenever the record has not moved. Every flag cites the captures it stands on — the string around the finger is tied to real evidence.

The card's live face: the expand button is deleted — Kymani himself never pressed it. Tapping the map now goes straight to the full world, one gesture, no middle stage. The draw pen lived only on that middle stage and left with it.

In its place the map screen carries a readout at its foot — IN RECORD, WORKING, VISITS — three honest counters machined into the bezel, so the held card tells you the state of the site without opening anything.

Then the two kinds of doors, matched to how buying actually works: SEARCH THE SHELVES opens Google Shopping, Home Depot, Lowe’s and Grainger with the query pre-typed; CALL A COUNTER lists the supply houses near you with distance and a CALL button, electrical distributors sorted first for an electrical part — because those counters never publish live stock, and the honest tool hands you their number with the part name ready in your mouth. Counters come from OpenStreetMap, free. No shelf we cannot see is ever spoken for.

The share fold's duration buttons and COPY LINK are keys; the SEND sheet is a module with the big blue key; the avatar and the NEW SITE blank joined the same language.

Why: one visual grammar everywhere — everything you can press looks pressable, everything live sits behind glass. The Terminal direction from the design canvas is fully on the app.

Workers plug in as dashed modules below the keys; QUERY sits as its own pink key; THE FIELD door at the foot of the pile is a mechanical key you can feel wanting to be pressed.

Why: the app should look like a field instrument you want to pick up, not a form you have to fill out. This is the first pass of that language on the live app — more surfaces follow.

The law that makes it trustworthy at a live panel: transcription only. A label the eye cannot read prints UNREADABLE — never a guess, never a completed word — and the caveats line says exactly what glare or crop hid. Electricians hate typing panel schedules; now the record types them.

Why these three: a contractor does not get paid when the work is done; he gets paid when the documentation survives an argument. The record already holds the evidence — the gumball machine just turns the crank. Measurements now speak in the document corpus too: a walked run reads as MEASURED n ft along the walked path, so the as-built can cite the tape.

"Collection and world are practically two views of the same thing — I don't wanna have two doors for the same room." One door now: ⊕ THE FIELD (N). It opens as the land; the land's own ▦ CARDS pill flips the same record into the binder view. Two views inside, one door outside. COLLECTION as a separate door is deleted.

"I never want to have to scroll in a card to use it." The ADD rows became THE TOOL GRID: six capture tiles three-across — pip, word, count — with the three worker seats (PHOTOGRAPHER · SUPER · LOADOUT) as dashed tiles beneath, the whole face visible at once. The press law is unchanged: an armed tile inverts to its own ink and asks START?/SURE?. The redundant QUERY seat in the grid area was cut — the face already carries one, and one door per room applies to me too. And SUPERINTENDENT became SUPER, because that's the word the trade actually says and the one that fits a tile.

Every screenshot in this entry was taken from the running app before pushing. The loop is: shoot, change, shoot, ship.

THE SHEET FRAME: home has claimed to be drafting paper for months without one printed mark saying so. It is a drawing sheet now — a double rule inset from every edge, registration ticks in the corners, painted under everything paper and covered entirely by the dark instruments. The single biggest identity move the app has made since the cards.

THE FIRE ON THE WORDMARK: the brand rule finally on home — TRADESMAN wears its orange dash where the law always said it should.

THE TITLE BLOCK: COLLECTION and ⊕ WORLD stop floating as underlined words and become bordered FIELDS in a drawing's title block — the same doors, printed like the sheet they always sat on.

THE QUERY SEAT RE-MATERIALIZED: seen with real eyes, the rose wash read as a loud off-material widget on the card's stock. It is a printed control now — stock ground, the card's own hairline, the rose reduced to one small pip that names the trade.

Also healed (third time the gate caught this class): another session's devlog entry with bare-string notes was failing every deploy.

DOTS SIZED TO THE CLOUD. The fixed 0.0026 was measured on one dense fused ARCore scan; a 442k-point X5 walk of a room is far sparser and the same size leaves a hole between every pair of points. The viewer now samples real nearest-neighbour distances off the probe's own spatial index and sizes the dots to the median — 13 mm on the 8/20 walk, 44 mm on the sparse alley. Measured per scan, never guessed.

EXPOSURE, NOT A MULTIPLY. That walk renders at a mean luma of 11/255 — jobsite interiors photograph dark and the voxel-mean fusion pulls them darker. Colours now go through 1-exp(-c*2.3): shadows lift hard, highlights roll off instead of clipping. The LIVE delta path gets the identical curve, so a walk no longer changes brightness the moment it stops streaming.

A GROUND AND A HORIZON. The floor plane the probe already finds now carries a one-metre survey grid — the ruler that makes "that wall is three metres away" legible without reading a number — under a plain gradient sky, with linear fog carrying grid and far dust into the same horizon colour. Both re-centre on the walker every frame (grid snapped to whole metres) so the horizon travels with you instead of sitting wherever the scan's origin landed.

AND A REAL BUG UNDER IT: the floor was searched in the bottom 45% of the RAW bounding box, which outliers set. On the 8/18 alley walk that put the floor 8.8 m underground — so every HEIGHT FROM GROUND on that scan was wrong by eight metres and the grid drew the alley floating in the sky. Percentiles of the actual points (p2/p98) fix the floor, the sight distance, and the measurement.

Two more so the first frame lands: the camera opens at eye height off the REAL floor (it used to open at a hardcoded y=1.5, underground in any cloud whose floor isn't zero) facing the direction holding the most surface at a readable distance — you stand where you stood, looking at the room instead of at a wall 40 cm from your nose. And on-screen dot size is clamped, so a floater beside the operator draws as a dot, not a dinner plate.

The splat stays exactly where it was, behind MODEL. Nothing about this touches the pipeline — same points.bin, same minute, same walk.

Now: a plate gets three rungs. If it cannot seat near its ground, it FOLDS into its nearest seated neighbour, and the neighbour wears the count — PARKLAWN TERRACE +4. Every project is still present, as ink or as a number; pinch in and they unfold naturally, because closer camera means fewer collisions. A lit plate — query proof — never folds: proof outranks the fold, the same law spots obey.

Strobe-proofed: the 60fps projection loop used to resurrect anything on screen between the 90ms ladder passes, so a folded plate carries a foldedOut flag and stays down until the ladder itself seats it again. Counts write only when they change; a still sky costs nothing.

This closes the ledger's №5. The world at survey altitude should now read like an instrument: a few named plates with honest +N counts, the land, the scrubber, the bar.

One seam physics: every instrument raise wears the same curve (cubic-bezier .22,.61,.36,1), durations joined one family — 450ms raises, 900ms for the card's living face. Nothing navigates; everything raises and lowers with the same hand.

And acquisition answers now, per the Game-Feel Line: a photo saving, a video banking, a walk sending — each gets exactly one haptic and one reveal sound at the moment the work is real. Nothing more; quiet stays the reward.

Done in lane B with the measure session's ground untouched — their splat-framing work landed cleanly beside this.

Nothing stamps scene_pose on the gaussian-SLAM path — worker.py only writes one on the COLMAP/Brush tail — so SplatWalk fell back to a fixed radius of 4 and a legacy Z-up rotation. But x5_slam.py already gravity-aligns its output (floor plane onto +Y, floor at y=0), so that rotation TIPPED a standing model onto its side, the orbit centred on the origin while the model's mass sat two metres off it, and the camera parked 8.8 m away no matter whether the walk was a 7 m room or a 150 m alley.

So the model now frames itself. When no scene_pose is handed in, SplatWalk measures the loaded splat's own centres: median centre, p90 radius (floaters must not decide the framing — the 8/18 alley model's raw bbox is +/-77 m around a walk you can see in 20), and the floor found by slab density the same way fastx/x5_slam.py's _gravity() finds it. No floor found, no rotation — a model with no findable ground is left standing as it was solved rather than turned onto a guess.

The hand is live from frame one. Drag, wheel and pinch listeners used to be attached AFTER the 30 MB PLY finished downloading, so every gesture in the first twenty seconds vanished into nothing and the screen read as dead. They are attached with the canvas now, and the loading line counts the download: PULLING THE MODEL - 62%.

Honest note on what you'll see: the framing is fixed, the models are not. The 8/20 walk renders as a spiky iridescent cloud, not a room. That's the solver's verdict to answer, not the viewer's.

The model in one sentence: a binder of living project cards on a drafting table, and every card opens into instruments. You HOLD paper; you LOOK THROUGH instruments; workers WORK for you; QUERY proves. His three tastes each get one layer: Apple governs the paper, the defense contractors govern the instruments, and mobile games govern the seams — craft, never mechanics.

Seven laws: the Two Materials (paper vs instrument glass — why COLLECTION and WORLD rightly look different), the Three Altitudes (binder → card → instrument, each answering one question in three seconds), the Physical Seam (everything raises and lowers, nothing navigates), the Voice (single plain verbs; type castes), the Game-Feel Line (juice on real events only; the one progression is real inventory), Field Ergonomics (gloves, one thumb, sunlight, quiet as the reward), and Density Budgets (three names on the rule, ever; new capability lands inside an existing noun before it may be chrome).

And the rename he called: ASK is QUERY everywhere a user reads it — "makes it clear you're doing a grounded task like searching, not abstract." QUERY answers with cited proof; FIND browses exact matches; the pair rides every instrument. Nineteen strings across six files; the code's own names stay.

The violations ledger ships open and honest: the world instrument is still over-dense at binder altitude, the seams aren't yet one physics family, and a capture banking is still silent. Worked top-down from here.

The fix was already written in his own law (2026-08-13: one face holds every tool — every move lives on ADD): workers ARE moves. The WORKERS tab is deleted at hours old; the three workers now sit as rows at the foot of the ADD face under one quiet label — WORKERS, START ONE ON THIS GROUND. Still started from the job's card, which was the whole point.

The rule is back to the three names + SETTINGS that always fit. A fourth page name does not fit on a trading card and never will — written into the source so nobody re-adds one.

Now the card states its ONE next-most-valuable input, in its own voice, with the why attached — never a checklist, never a badge. One line at the top of the tools face; tap it and the right tool opens; feed it and the line disappears. Quiet is the reward.

THE HIERARCHY, settled as law: 1. THE SCOPE — one typed sentence about what the job is; the cheapest input with the biggest unlock, because the LOADOUT and ASK reason from it. 2. EYES — the first photo; the record starts existing. 3. THE WALK — before the walls close; the whole site remembered. 4. THE PAPER — the bid or plans; a bid literally lists the materials, and the LOADOUT reads it straight off the page. Fed on all four, the card says nothing.

This closes the loop the plaza morning opened: the LOADOUT needs a scope to reason from, and now the card itself asks for the scope in one tappable sentence — 'This card doesn't know what the job is yet. SAY THE SCOPE ⟶.'

He asked for substantiation, not agreement, and the numbers agree with his gut: field crews spend only 30–50% of paid time on direct work, with waiting for materials and equipment among the biggest sinks; workers average ~38 hours a year just hunting tools; on measured housing projects, waiting alone ate 23% of working hours. Forgetting things at the shop is not a personal failing — it is the industry's oldest tax.

THE LOADOUT is the third worker on every card: press it and the record writes the truck list before you leave the shop. Three parts, ordered by how expensive each item is to forget: the MATERIALS the documented work consumes, the TOOLS it requires (cutting #1 copper implies a cutter rated for it), and the ENABLERS the material itself creates — the reel-jack class of need, implied by the wire, owned by nobody. Every line cites the work it serves and carries its because; where the record can't settle a fact that changes the list, it writes the QUESTION to answer before the truck rolls.

It is the one document kind whose job is inference — and the engine's no-inventing rule holds: it may reason forward from cited work to what that work needs, never invent what exists on the site.

He was quoting his own August 7th law back at the feature without knowing it: nothing in the app exists outside of cards. The home crew block violated it and lasted one day. Deleted — along with the WORK button that confused him (it fronted a card that was already front; a button that visibly does nothing is worse than no button).

The good half moved where he said it belongs: the card's WORKERS page now seats the full startable crew. PHOTOGRAPHER — clocks the camera in on this ground. SUPERINTENDENT — writes today's report from this card's record, every line with its proof photo, and sends it to whoever this site remembers. Start a worker from the job it works for. That's the sentence.

And the nostalgia he smiled about naming — missing the card app — got its honest answer: it isn't weakness, it's the ontology asserting itself. The cards were never the old app. They're the app.

DELETED, properly, not commented around: the auto-opening world home (the world is a door you choose — ⊕ WORLD — never a place you wake up; do not rebuild it), and the chrome crew plaques that collided with the world's own pills. The crew still stands ON THE LAND as name plates, which is where presence belongs; chrome carries no roster.

BUILT, from the board he pointed back to: THE CREW, on the paper home, above the pile. Three rows. YOU — the operator, one verb, WORK, which fronts the site you're standing at or worked last. PHOTOGRAPHER — START, stands the camera up on that same ground. SUPERINTENDENT — SEND, which writes today's report from the record and sends it, because that IS its job. The pile below is untouched; this is the crew above the ground, not a second app.

Everything else from the synthesis survives where it made sense: the card fronting when you enter a project from the world, SEND THE DAY with the remembered GC, the offline law, the first-open beats, and the SLAM model on the Bethesda walk.

THE OFFLINE LAW WENT LIVE: the app watches the connection the whole session, not just at launch. Signal drops with the world up → the world folds to the pile with one plain sentence, and the margin prints NO SIGNAL — WORKING FROM THE PHONE'S COPY until it returns. The storage was always honest offline (the relay banks, the vault holds); now the screen is too.

THE CREW STANDS ON THE LAND: workers stopped being chrome. Every clocked-in camera with a position is a standing name plate at its real GPS — YOUR PHOTOGRAPHER — WORKING, tappable into its ground — and YOU stand there too, one cached position read, never a gate, never off-frame confusion (a plate outside the framed metro stays down).

AND THE MODEL ARRIVED WHERE THE FOOTAGE ALREADY WAS: the gaussian SLAM, proven on the Parklawn walk's own relayed chunks (rendered against its own photographs at 20 out of 255), is now published onto that walk's job — open the Bethesda card's twin and MODEL is lit. Nothing was re-walked; the footage the field already paid for earned its model retroactively. Every NEW walk solves with the SLAM live — the operator card's switch has been on since the night it shipped.

Still a human's job, said plainly: the photographer's first real tripod shift, and one real walk on the new home. The code is done waiting; the field is the last reviewer.

THE CREW PRINTS IN WHOLE WORDS. "You · AT PURPLE LINE." "Your photographer · WORKING · GLEN OAK." world-view now ships every camera clocked in as a worker, and the world names them like people instead of drawing cryptic dots — because a worker you can't read isn't staff, it's noise.

SEND THE DAY — the one blue verb. When today holds work, the world's day bar says so and one press packages it: the daily report the record writes (every line cited), plus a 7-day live window, handed to the share sheet — text it to the GC, done. No email machinery; the text thread the trade already lives in IS the delivery.

THE FIRST OPEN: three beats, one noun each — here's your worker, here's your record, press one button and the day is sent. Shown once, then never again. The introduction carries the comprehension so the app never has to explain itself.

Honest ledger: phase 0 (field-proving the walk and the photographer's first shift) is still owed and is a human's job; the world-home is code-verified, not yet field-verified.

THE INSTANT STOP. Kymani: 'I have to keep my phone open for a long time where I expect instant upload.' Two holes closed. The drain stood him there up to 45 seconds watching chunks send — but the relay is a FOREGROUND service with a wake lock; it keeps uploading with the phone in his pocket. STOP only ever needed the walk's true chunk count, which exists the moment the tail chunk rotates — so it reads the count, files the job, and hands the phone back in a couple of seconds. And the crueler hole: when the START-time live submit had failed (flaky signal in a walk's first seconds), stop threw the WHOLE relay away and fell back to the multi-GB archive pull — chunks already sitting in the cloud, operator parked in a lot anyway. The finalize call now carries everything a fresh job needs (siteId, chunk_ext h264 — the fallback default was webm, the exact two-names-for-one-file bug that already hung every live walk once), so a failed start can no longer cost an instant stop.

THE MAP GROWS TO THE CARD. The FULL door on the living face is gone; in its place an ⤢ expander grows the map to the whole card — same DOM node, same GL context, no remount and no second tile session — and flips the world interactive (angles, chrome, FIND DATA). On the big map: ✎ DRAW, the surveyor's spray in the brand fire — sketch runs and notes for the crew, screenshot to share. Strokes live on the phone and nowhere else; no rendered map frame ever leaves the device (the tiles law), which is exactly why the screenshot is the deliverable.

WORKER TOWERS — the camera clocked in as staff. Kymani: 'with some code and a loop I can make an Insta360 basically a sentry tower or an independent worker.' The card grows a WORKERS page and the first hire is THE PHOTOGRAPHER: stand the X5 where it sees the work, pick a shift (30 min / 1 hr / 2 hr), clock it in. The phone stays beside it as the relay — same chunks, same prefix as a live walk — and the box develops the shift with no GPU at all: frames scored by sharpness, the best shot per minute, blur-gated against the scene's own baseline, capped at 24, uploaded as real photos and inserted into the pool with no index_v — so the existing index pass gives them the one exhaustive eye and they become askable like anything a human shot. Deliverables, from a tripod.

THE LIVE LINK GROWS A LIFETIME. The row unfolds: 1 DAY / 7 DAYS / 30 DAYS / FOREVER, and the ACTUAL URL prints on the card with a COPY button — the old flow copied silently to the clipboard, and a link you never saw is a link you can't check before texting it to a customer. The expiry rides INSIDE the key (hmac.expiry, signature covers the expiry), so every pipe that carries a share key — the live page, the ask, the reports — keeps carrying one opaque string, and no one can stretch a link's life without breaking its signature. Verified: forever keys are byte-identical to the old scheme, so every link already in someone's texts keeps working; an expired link says "this link has expired" instead of a bare 403 that reads like the site is gone.

FIND AND ASK ALWAYS PRINT, and their names now carry the split: ⌕ FIND DATA is OBJECTIVE — exact words from the record, grepped; ASK QUESTIONS is REASONING — the record thinks an answer out. On a site with nothing recorded both stand greyed and say so, because a control that only appears once there's data teaches nobody what the product does.

And the home margin sheds a line: THE FIELD · N SITES is gone, the count sits in parentheses on COLLECTION — the number now lives on the word it actually counts.

The clock now starts at the LAST SIGN OF LIFE: max(created_at, stats.stage_at) — stage_at is stamped by the retry route and by the box on every stage change, so a retried walk gets its full budget and a genuinely dead one still dies on schedule. Retry also clears the terminal columns (error, completed_at) a previous failure left behind, so a running walk can't wear a dead walk's toe tag.

Walk 6 is sitting at failed from the watchdog's kill — RETRY prints on failed rows, so the fix is one more tap after this deploys.

No worker change, no restart, no hands: this is app-side only, riding routing the box already obeys. If the chunks were cleaned from storage the replay fails honestly (no chunks ever arrived) instead of pretending.

The worker now also checks between jobs, every ten minutes while idle: pull --ff-only; if worker.py itself changed, prove the new file compiles, then exec into it — same PID, the scheduled task never notices. A worker.py that won't compile is logged and NOT exec'd; the running copy keeps working, which beats a box stuck in a two-minute crash-restart loop with nobody home. Child scripts (the solvers) already refresh per job once pulled.

The honest chicken-and-egg, said plainly: this fix is itself a worker.py change, so it takes effect at the box's NEXT restart — a Windows update, a power blip, or one last hand on the machine. From that restart on, anything merged to main is running at the shop within ten idle minutes, forever, and the phone is genuinely the only tool needed.

run_x5_dense now honors the switch: when GAUSSIAN MODEL is on, the solver stage runs fastx/x5_slam.py in batch — same frames, same reprojected pin dir, DONE down before launch so it consumes everything, runs the full-resolution polish, and exits holding model.ply + points.bin, both published (points_url + splat_url, model=x5-slam). Live, retried, and uploaded walks now all obey the one switch.

Two deliberate details. The SLAM gets its own frame cap (X5_SLAM_MAX_FRAMES=60, not the dense path's 10): the tracker needs the sequence's small inter-frame motion — the proven Parklawn replay was 48 frames — and thinning to 10 spread views starves coarse-to-fine. And a missing gsplat toolchain now FAILS the job loudly with stats.slam_error instead of quietly substituting the point-cloud solver — a substituted model is how a test you meant to run never runs.

So the gym-to-model path is real now: GAUSSIAN MODEL on → RETRY on a stuck walk → the box re-solves it with the SLAM → the MODEL toggle appears on the twin page. Compiles clean; the first retry against the live box is the field test.

Every row gets a TYPE PLATE: a solid pill in the type's own ink — 360 WALK on X5 purple, PHONE WALK on footage blue, NOTE on paper, PAPER on manila — the same grammar the SPACE and STILLS chips already speak. The faint colored glyph-text it replaces (◎ 360 WALK 6) read as decoration, not identity.

The filter bar doubles as the legend now: an unselected chip's word wears its type's ink, so walk=purple and video=orange is learnable without tapping anything. And the clip tile's corner badge always carries its word — ▸ VIDEO 0:22, never a bare duration.

One line of copy got honest: a done walk with no space used to read FOOTAGE — STATIONS PENDING, forever, while nothing was coming. It reads FOOTAGE ONLY — NO SPACE YET, and the RETRY word standing beside it is the way to change that.

The timeline row now prints RETRY exactly where it can act: the space never came (or the build failed outright) AND the source bytes still exist to re-run — video_url, chunk set, or bundle. Phone footage is excluded; a pinhole clip has no space layer to rebuild. One tap re-queues the row on the same rails the worker's own backoff uses: status back to processing, lease and dead-letter cleared, and attempts=1 ON PURPOSE — above zero is what makes the worker wipe the partial COLMAP/Brush state and rebuild clean instead of re-crashing into a corrupt half-solve (its own self-healing path, now reachable by thumb).

The route refuses to stomp a working job: a processing row whose lease is younger than the worker's 20-minute TTL answers 409 — a working walk and a stuck walk are different things and only one of them needs rescuing.

Honest edges: a retried LIVE walk re-runs through the batch path (live_done stays set), which rebuilds the cloud and stations — it does not produce the gaussian SLAM model; that path is live-walks-only today. And a live walk whose chunks were cleaned from storage will fail its retry with a clean error rather than pretending. Typechecked and production-built before push; not yet exercised against the live box.

tools/shopbox/publish_model.py closes that gap: point it at a replay workspace and a job id, and it uploads points.bin and model.ply on the worker's exact rails (same bucket, same output/<jobId>/ paths, same stats keys) so the twin viewer grows its cloud and MODEL toggle after the fact.

It refuses to overwrite a points_url or splat_url the job already has unless --force is passed — a proven cloud must never be silently replaced by an experiment. Untested against the live project from the sandbox it was written in (no network path to Supabase there); it mirrors stations.py's standalone pattern and the worker's publish block line for line, and the first run on the box is the test.

GAUSSIAN MODEL toggles whether a live X5 walk is solved by the gaussian SLAM (which leaves a model you can hold) or the point-cloud solver (which is what has survived real field walks). BOX WORK is RUNNING or PAUSED. Paused takes no NEW work and never interrupts a job already running — that is the only thing a box behind a home NAT can honestly promise, and promising more would be a lie.

There is no such thing as sending the box a command: nothing inbound can reach it, no public IP. So the control is the HEARTBEAT RUN BACKWARDS — the app writes scan-videos/shopbox/control.json, the worker reads it on every poll, exactly mirroring how the app already learns the box is alive. Same channel, same shape, no new machinery, and it fails safe: a control file that cannot be read leaves behaviour exactly as it was rather than changing it on a network hiccup.

The switch is also read PER WALK now instead of once at startup, which is the part that actually stops the pain — trying the other solver no longer means editing a file on the shop PC and restarting the worker.

It is OFF by default and that is deliberate. The cloud solver is what has survived real field walks; this one has been proven on exactly one replayed walk. A switch you have to throw is honest about which is which.

One trap worth recording. The obvious way to launch it — cmd /c "call gsenv.bat && python x5_slam.py" — does not work: cmd mangles its own quoting when the line carries several quoted paths and answers with 'is not recognized as an internal or external command'. That reads exactly like a crashed solver, from a solver that never ran. So the batch file runs ONCE, its whole environment is read back out of `set`, and that gets handed to a normal launch. No shell at spawn time, nothing to quote. If the toolchain is missing entirely, the walk says so and falls back to the cloud solver rather than producing nothing.

Verified end to end on the box, not assumed: the environment captures (121 variables, CUDA_HOME set, nvcc on PATH), the solver launches under it, and model.ply and points.bin appear on disk DURING the walk — 43 MB of gaussians by frame 44.

FIRST, growth without a neural net. The old densification seeded every uncovered pixel at ONE guessed depth and produced soup — measurably worse while making the training loss look BETTER. It grows surfaces outward from surfaces now: each uncovered pixel takes the depth of its nearest mapped neighbour, only within a narrow band of real geometry, and sky is refused outright (bright, colourless, no depth is right for it — sky at a guessed depth is why the raw cloud measured 141 m across for a 40 m walk). 50.6 -> 40.0, and 166k gaussians became 507k.

SECOND, the polish at STOP. During a walk, refinement can only afford the last few keyframes, so the map forgets where it has been: the newest keyframe rendered at 16/255 while the FIRST had decayed to 52. One pass over every keyframe at full resolution, with the poses free to move, costs 73 seconds and fixes both the forgetting and much of the softness. 40.0 -> 20.3. This is what STOP MEANS DONE is for — the walker has stopped, so the GPU is finally free.

THIRD, a hard limit found rather than assumed. Re-running MapAnything on new ground in a background thread saturated the card at 8001 MiB of 8192 and the walk stalled. A giant solver, a growing map and live tracking do not fit in 8 GB together — which is precisely the argument for taking the net out of the live loop. It stays available behind a flag for offline quality work; the live path needs no VRAM for growth at all.

Honest state: this is a real, recognisable, walkable reconstruction, not yet a photoreal one — it is soft, and doubling the gaussians and tripling the polish only moved 20.3 to 19.5, so sharpness needs adaptive splitting, not more of the same. And it runs at about 3.3 s per frame on a 1 fps walk: realtime in SHAPE (cost no longer grows with the length of the walk) but roughly 3x off realtime in fact.

THE MAP IS GOOD. Rendered from a bootstrap camera's own pose, the reconstruction is unmistakably the alley — the asphalt, the grass, the orange barrier as a red mass, the sidewalk. 27/255 against the photograph. THE RIG MODEL IS FINE TOO: rendering with MapAnything's own per-view poses (19/255) versus the one-rig-pose model (22/255) is a small difference, so treating the six-view ring as a single camera is sound.

THE TRACKER WAS THE ERROR. With the map FROZEN — literally the same gaussians — rendering from a bootstrap pose scored 27/255 and from a tracked pose 52/255. Nothing but the pose differed, so the tracker owned all of it.

The cause is structural and worth remembering: a walk sampled at 1 fps moves about a METRE between frames, and direct photometric alignment only converges from inside a basin roughly the size of the features it is matching. At full resolution a metre is far outside it, so the solver settles into a local minimum and returns a confident wrong answer. Solving at 1/8 resolution first turns that metre into a few pixels. MEASURED, same frozen map, same frame: 52 -> 35, and every view improved.

The map-grower is now the known-broken half, and it ships OFF rather than shipping damage. Refinement against tracked poses made things worse (27 -> 52, and 35 -> 95 further along, with coverage collapsing as gaussians were dragged off surfaces), and local bundle adjustment with the poses free did not rescue it (48). The honest consequence: the model currently covers the frames the bootstrap saw, and the walk beyond that is tracked but not yet mapped.

Next lever, stated as a hypothesis rather than a fix: the optimizer's learning rates are absolute, while 3DGS scales the mean learning rate by scene extent — and this scene is about 100 m across.

What is proven on Kymani's Parklawn walk, 48 frames: 0.5–1.4 seconds per frame, which is walking speed, in 2 GB of the 8 GB card at 12% GPU. A walk ends holding a model.ply AND the points.bin the current viewer already draws, so the new format is never the only format. Tracking error falls as the map fills — the behaviour tier 3 is supposed to have.

What is NOT right: rendering the finished model from the camera's own pose does not reproduce what that camera saw. The layout is roughly correct — canopy above, road below, the orange barrier showing as a red mass — but it is not the alley. So the loop is real and the reconstruction is not yet.

Two of my own bugs found and fixed by measurement rather than guessing. Every gaussian was born the same 9 cm blob (one global median spacing), which makes far geometry gauze and near geometry a smear across the whole frame — it is per-point local spacing now, the standard init, for a reason we can now see. And colour was unbounded during optimization, so Adam drove it outside 0..1 to buy a little loss and smeared MAGENTA through a scene containing no magenta.

One thing settled by a control run rather than opinion: densification that seeds new gaussians at a single guessed depth makes the model WORSE while making the photometric error LOOK better — it sprays image-coloured blobs at a fixed radius. Growth is behind a budget switch, and 0 is the honest setting until depth for new ground comes from somewhere real.

Next is a bisect, not a guess: render using MapAnything's own per-view poses instead of the rig model. If that matches the photographs, the bootstrap map is good and the rig-pose model is wrong; if it does not, the fault is upstream in the bootstrap.

gsplat is the right rasterizer and it is Apache-2.0. That matters more than it sounds: MonoGS and Photo-SLAM, the two obvious papers to copy, are built on Inria's rasterizer, which is licensed for NON-COMMERCIAL research only. Building the free-for-every-tradesman thing on top of that would poison it. We take the method from those papers and never their kernels.

Three real walls, all now down. gsplat JIT-compiles CUDA on first use and there was no nvcc on the box — and no room for one, C: had 8.8 GB free and a near-full C: is a documented way to break this machine. Rather than a 3 GB installer, CUDA is now three official NVIDIA redistributable archives (nvcc + cudart + cccl, 127 MB) unzipped into one toolkit root on D:. No installer, no registry, nothing on C:; delete the folder and it is gone. For the record the pip shortcut does NOT work here — the Windows nvcc wheel ships ptxas and headers but no nvcc.exe.

Then two failures that both lie about their cause. Windows' rpcndr.h does `#define small char`, and torch's own header declares a parameter named `small` — so a PyTorch header fails to parse and it reads like a broken torch install. Compiling with WIN32_LEAN_AND_MEAN excludes the RPC headers and it is gone. And gsplat hardcodes GCC flags for the host compiler, which MSVC rejects outright; that patch now lives in tools/shopbox/patch_gsplat.py so a pip upgrade cannot silently revert it.

MEASURED: kernels compile in 283s once, then load in 0.4s forever. Gradients confirmed flowing to the camera pose, which is the whole point — not just that it renders. The road to walking into a model is open.

Also fixed: the law file was describing an app that stopped existing an hour earlier. CLAUDE.md still said THE LIVE MAP IS THE PER-SITE ASK SURFACE and that an in-card ask face was deleted, do not resurrect — while the card was, at that moment, answering in its own body on prod. A rule nobody can trust is worse than no rule, so it now says what is true: the card answers, one transport (lib/ask-stream.ts) feeds both renderings, and the map is a place you choose from an answer rather than a hallway you walk through to ask a question.

Said plainly, because it is the honest version: two sessions built the same fix from opposite ends this evening. The card-body rendering won on merit — it costs no navigation at all — so the full-screen ask face was dropped rather than shipped beside it. What survived from the other end is this: the door now carries what it promises.

ASK streams into the card. The route already spoke NDJSON, so the card shows the same three beats the full surface does: first the true scope of the read (READING 178 CAPTURES · 41 PHOTOS), so the wait is never blank; then the answer as the model writes it; then a door to the map for the proof. FIND filters as you type and lays the matching frames out as a small grid right there — tap one to open it, or take the whole day into the timeline.

THIS AMENDS A LAW, DELIBERATELY. On 2026-08-13 the live map was made the per-site ask surface and CardAsk.tsx was deleted with a do-not-resurrect note. Two field verdicts overturned it, both his: "I cannot imagine anyone asking a question", and then, with a crew waiting at the shop, the map is "too clunky, too time consuming". The map keeps what it is genuinely best at — evidence, lit beacons, standing in the place — and stops being the way in.

ONE TRANSPORT, TWO RENDERINGS. The 2026-08-11 law said never a second ask implementation, and it still holds where it matters: the NDJSON reader moved into lib/ask-stream.ts and both the card and AskSurface use it. Two ways to see an answer, one reader, and no way for them to disagree about what the record said.

The card is still a card: the panel scrolls inside the fixed face like every other one, the input is 40px tall for gloves, and closing it puts the rows back exactly as they were.

FIND streams in the only sense that matters for a search: it filters on every keystroke, client-side, over data already on the phone. No request, no spinner, no signal required — it works in a basement. There is nothing to stream because there is no wait.

ASK has streamed since 2026-08-11, and the comment in the route is his own: "at least somebody will see it as it is coming in. Ten seconds of ASKING was the worst moment in the product." The answer arrives as NDJSON — first a READING frame stating the true scope of the read (how many captures, photos and papers it is about to look at, so the wait is never blank), then the answer text as it is written, then one final frame carrying the receipts, the beacons and the meter. Because the model writes its answer into a tool call, what streams is the tool JSON, and because `answer` is the first field in the schema, the prose is the first thing out. The route reads it out of half-written JSON.

WHAT WAS ACTUALLY MISSING: the API validates a tool call JSON before releasing it by default, so those deltas arrived in verified chunks rather than as they were generated. Turning on eager input streaming releases the partial JSON immediately — which is precisely what this route was already built to consume. Same request, same model, same cost; the first words simply land sooner. In the field the first word on screen IS the speed.

Prompt caching over the record was already on too, so a second question about the same card does not re-read the whole corpus. The remaining latency before the first word is the model READING — measured at about nine seconds with six full-resolution frames — and that is the honest next target: fewer or smaller images, not more streaming.

Measured against the live record: RoadGuard Interlock is pinned in Alexandria, 19.3 miles from his desk. It claimed the ground under him because of exactly one capture — a photo of ladders shot at the shop on Aug 15 at 1:52 AM, filed to that card BECAUSE IT WAS ABOUT that job ('the tallest ladders we could use for a place like roadguard interlock… next time get a second scissor lift'). Filing it grew the card's ground a mile around the shop. BAD DATA never flagged it either: no other card's address sits within a mile of his shop, so by the stray rule it was legitimate growth.

The gap: the accretion rule could not tell work done AT a job from work done ABOUT one. So a far spot now joins a project's ground only when it holds more than one capture EVENT — and two pins count as the same event when they are within 25 m AND 30 minutes of each other, because a 7-metre fix scatters one standing position across several metres and a burst of shots of one panel is one act of filing, not two visits. A lone far capture keeps everything else: its card, its place in ASK, its dot on the art. It just stops moving the fence.

Checked against every site and every pin in the record before shipping, not on a fixture: exactly two spots changed verdict, and both are the same shop (one filed to RoadGuard, one filed to Purple Poles this morning). Everything that is real work still lights up standing on it — Olney's three pins 24 miles from its address, the whole Bethesda purple-poles corridor, Glen Burnie. From his desk, no card claims him now; the nearest is Potomac Woods at 1.5 miles.

They stay two doors for a better reason than symmetry. FIND is free and instant: it filters what is already on the phone. ASK costs a few cents and a few seconds, because a model reads the whole card to answer. One merged field would quietly spend both every single time somebody only wanted to look at a photograph. Two doors let the tradesman choose the cost, which is the honest way to charge him for it.

FIND opens the timeline with the keyboard already up. ASK opens the site live map with the ask bar armed, exactly as the ASK row always did — this gives it a faster door, not a new home. ASK living only behind the live map is still a real problem, and the field verdict on that map is "too clunky, too time consuming"; the next honest move is for ASK to answer inside the timeline, over the same frames FIND is filtering. Reason and evidence in one surface instead of two.

Either half stands alone: a card with nothing filed yet shows only ASK, a card without the ask action shows only FIND, and whichever is present takes the full width. No card is different — the line just says what that card can actually do.

SEARCH IS ON THE FACE NOW. Not behind a tab, not behind a row. It is a field on the card itself, and it is deliberately a button dressed as a field: tapping it opens the timeline with the real input already focused, so the keyboard comes up once and what you type never gets split across two boxes. Three taps became none.

ARRIVAL. When you are standing on a card ground, the card now says what happened here LAST without being asked — LAST WORKED HERE, THU AUG 13, 187 PHOTOS — and tapping the line opens that record. It only prints while you are actually there, because that is the only moment it earns the space on a face where every line has to fight for room.

Nothing new was computed for either of these. The here badge existed, the pool existed, the day spine existed, the search existed. They were simply never said out loud at the moment they were worth knowing. A record you have to interrogate before it tells you anything is a filing cabinet; the point of this pass is a card that is already awake when you walk up to it.

This is the shell getting faster, not a new surface — no new door, no new datatype, no new page. The engine underneath (territory, accretion, the index, the timeline, the relay) is untouched.

So the margin carries two lines now. The verdict, then the input it was computed from: YOUR PHONE · 1420 ROCKVILLE PIKE, ROCKVILLE · GPS STRONG. The street comes back through our own elect-only geocoder, so it speaks in exactly the same words the card's address line does — two addresses in one voice can be read against each other at a glance; two formats cannot.

It prints in every state, because a line that disappears is a line you can't check: TURN LOCATION ON TO SEE IT when location is off (never an echo of the verdict — LOCATION OFF twice in a row says nothing the second time), FINDING YOU while the first fix lands, NO STREET ADDRESS HERE when the map genuinely has no street there. GPS quality stays a word. No coordinates, no plus-or-minus metres.

Two things kept honest under it: the fix is only re-read after it moves 40 m, so a watch that ticks every few seconds doesn't hammer a free public geocoder (a failed read backs off a minute rather than retrying every tick); and the new line's wrapped height is pre-paid in the pile's height arithmetic beside the dateline's, so a long address can never crop the deck's bottom edge — the exact bug class that ate the margin print once already.

The solver was launched bare, so it ran on its own defaults — win 12, overlap 4, sub 2 — the pre-measurement numbers that were corrected on the batch route on Aug 18 and never carried across. On this path they are worse: a window counts SOURCE FRAMES, and the live route turns each pano into a SIX-view yaw ring, so win 12 fed the model 72 views at once, half again past the ~48 views the box was measured to survive. It could not finish a single window before the walk ended.

Matched to the measured recipe (win 8 / overlap 3 / sub 4), and the worker now PASSES it instead of assuming it. The opening window is deliberately shorter — 30 views, cheaper than a steady one — so geometry lands in front of you in the first seconds instead of after you have already stopped.

The live walk also never left a record. The batch route indexes; this one didn't — so the capture path actually used in the field produced footage and a cloud and nothing askable. The Parklawn job finished with capture_count 0 and not one captures row. A walk you cannot ask is not jobsite memory. It indexes now, beside the webhook rather than in front of it, so the card never waits on it and a failed eye never damages a finished walk.

Still open, said out loud: a live walk produces no gaussian splat. The beauty pass shipped yesterday hangs off the .insv batch route only, and the live path ends at an equirect mp4 that the trainer has no route for. Next hand-off.

The idea was one of the good ones and it is worth being precise about why it failed, so nobody rebuilds it on the same ground. Shoot all day on the phone's own camera; tap CLAIM at the truck; every photo files itself to the card whose ground it was taken inside, using the GPS every phone already writes into the file. Nothing about that is wrong. What's wrong is that the GPS is usually gone by the time this app can read it. Android scrubs location out of anything a web file input can reach. Messengers strip it on the SENDER's phone, before it ever arrives. And the native picker built specifically to dodge both of those needed a photo permission that people decline — and once declined twice, Android will not let any app ask again. So the honest outcome, most times, was a receipt that said nothing filed.

Photos still come in, the same way they always actually did: the card's UPLOAD tray. You point at the files, you name the card by opening it, and nothing depends on what metadata survived the trip. That path has a location guard of its own that flags a file shot somewhere else — that part was never the claim's.

What was kept, carefully, because it lives in the same file the claim did: ingestToSite (the filing engine behind UPLOAD), the video upload rails, and matchSite — the distance math behind YOU'RE HERE. One pass at this deletion swept ingestToSite out with the rest; a guard caught it before it shipped. Typecheck clean, home renders, all six card tools intact.

Written into CLAUDE.md as a do-not-rebuild with the full reason, next to the other good ideas that lost to their substrate.

The binding constraint turned out not to be the GPU at all. The giant DINOv2 backbone plus a 16-view window sat at 11.4 GB, free memory fell to 4.3 GB, and the process burned 61 seconds of CPU across 30 minutes of wall clock — it was PAGING, not computing. Window size drives peak memory, so window size was the lever. Measured, end to end: 8 frames, 48 views, window 8, depth stride 4 → 262,150 points with gravity recovered, 4 minutes 34 seconds. His walk is now a place you can stand in, published to the card.

Both numbers are defaults in the worker now, and both are overridable so a bigger box can widen them again. The frame count is a CAP rather than a frame rate — evenly spaced, contiguously renumbered — because fps alone does not bound the work: 40 seconds at 1 fps already made 288 views, and a five-minute walk would have been seven times worse. The far end of a long corridor still gets frames; they are simply further apart. (Renumbering matters: the solver walks the sequence, and a hole in the numbering is a FileNotFoundError. Learned that one by doing it.)

It is three lines now, in two voices. The sheet SPEAKS in the quiet margin print: THE FIELD · 13 SITES, state and nothing else — its door moved out, because a caption that is also a button is the exact ambiguity that made this foot unreadable. The sheet ACTS in one bold line: COLLECTION · CLAIM · ⊕ WORLD. And the two links that actually leave the app wear an underline — the only underline on the page — which says 'link' without spending a third size or a third weight on saying it. The rule is gone; air does that job.

One word changed. ASK THE WORLD is now WORLD. That door stopped being an ask months ago — asking happens standing IN the world, where the answer's proof ignites on the ground; the code comment already called this end 'purely a door'. The shorter name is also what lets all three doors hold one line on a phone. Say the word and it goes back.

The thing that made this hard is worth writing down: the margin lives INSIDE the pile's fitted width, which is 163 pixels on a short phone. Every line down there has always been wider than its own container and survived by overflowing it. The door row wrapped after a dangling separator until it was told the same — overflow, don't wrap. It wraps for exactly one case, mid-claim, when the door is carrying a progress string of unknown length.

Measured at 360×640 and 390×844: three lines, five targets, every one of them 44 pixels tall. And the shorter margin handed room back to the card above it — the hero now shows all six tool rows on a short phone instead of five and a half.

The solver was segfaulting. Not from a bug in the solve: the 8 GB card had 7,822 MB of 8,192 already committed — Chrome, Steam, the Epic launcher, BlueStacks, the Windows shell, and an ORPHANED x5_live.py from an earlier run still holding the card hostage. The model had nowhere to load, so it died on arrival. Killing the stale solvers took the GPU from 7,750 MB to 930 MB and the model loaded in 63 seconds on the next try. Worth saying plainly: the shop box is also the daily-driver PC, and an 8 GB card shared with a browser and two game launchers cannot be relied on to hold a walk.

But the reason this took an hour to find is the part worth fixing forever: the solver's stdout and stderr went to DEVNULL. A crash that loud left no trace at all. It writes a log beside the walk now, and a walk that ends with no cloud says so on the job (cloud: failed, with the solver's exit code and the tail of its output) instead of finishing quietly. The next time this happens it will take a minute, not an hour.

The two halves of the relay disagree about a filename. The phone banks chunk_00042.h264 locally; /api/scan/supa-upload-url parses the index out of that and stores it as 00042.h264 with no prefix. The worker's chunk listing only accepted names starting with chunk_, so it saw an empty bucket forever — and after fifteen minutes failed the job with 'no chunks ever arrived', a true sentence about a walk whose bytes were sitting right there. This was never a one-off: it breaks EVERY live walk, and the reason it was never caught is that the box has been offline since Aug 4, so nobody ever watched one run.

The listing accepts both spellings now and sorts by chunk INDEX rather than by string, so a bucket holding a mix still lands in walk order. Verified against the real names in his session before restarting the box on it.

Also found while getting the box hot: the TradesmanShopbox scheduled task exists but its state is Disabled — last run Aug 4, terminated. That is the whole story of the 'hot server' that keeps going cold. Re-enabling it needs admin, so it is the one step waiting on Kymani's own hands.

That is the first time this app was useful to somebody who is not its author. It is also two bugs wearing a success for a coat.

BUG ONE: he found it by EYE. Alex asked a textbook query and the answer was a scroll, because the deliverable was never a sentence — it was a photograph he could hold up in a room. BUG TWO: FIND existed the whole time and lived only inside the world/flyover, a surface whose field verdict is "too clunky, too time consuming". The only search over the record sat behind the one door he would not open with a crew waiting.

So search now lives in the timeline, where the record is actually read. Type mule tape; the day spine narrows to the days that hold it, still as days, still with every kind in them. The count line says how many match instead of how many exist, and when nothing matches it says so about the SEARCH — "nothing here matches mule tape" — never "no photos here" in front of 278 photos, which is a lie the record would be telling.

It searches what the MACHINE read, not just what a human typed. The index already ships a summary and equipment labels with every photo, and that is the only reason mule tape can find a frame whose own note says nothing — on his own Bethesda day the notes read "No note.", "2945 in", "1031 inches". A search that only read human notes would have failed the exact question that started this.

Numbers match whole, per the pole7-is-not-pole77 law: searching 7 finds pole 7 and refuses pole 77; searching 2945 refuses 29450. Verified against a table of thirteen cases, including the real measurements off that day.

No new surface. The search sits in the door that already exists, on the face he was already using when it mattered.

But the question found a real hole in yesterday's beauty pass. The 3D door only appeared when the dense CLOUD existed — so a walk whose cloud failed and whose gaussian model trained fine would have had no way in at all. The door now opens for a finished splat as well. The half-trained Brush checkpoint stays banned, which is the distinction that matters: a finished model is a deliverable, a checkpoint pretending to be the twin is how the app once showed dark fog.

First: a walk did not produce a splat at all. The .insv route publishes MapAnything's dense cloud and returns; the COLMAP-and-Brush tail has been behind an off-by-default switch since August 6th. It publishes TWICE now — the walk finishes as it always did (footage, record, cloud, about a minute), and then the trainer runs on for the model and patches it onto the same job. Nothing waits on the slow half, and a failed model never damages a finished walk: the card says MODEL TRAINING ON THE BOX, then either the model or NO MODEL FROM THIS WALK. SHOPBOX_X5_SPLAT=off turns the beauty pass off when the queue matters more than the model.

Second, and worse: the app had nowhere to SHOW a splat. The twin viewer renders point clouds and says so in its own comment — MAPANYTHING ONLY. A trained .ply would have been a file in a bucket. The splat viewer parked back in July is restored and grown up: the trained model now opens IN the twin route with MODEL / CLOUD·MEASURE, defaulting to the model because it is the better likeness, with the cloud one tap away because that is what the tape and the H/D/P gizmo measure against. Verified for real, not just compiled — a hand-built 100-gaussian .ply rendered, levelled and orbiting, before a byte of it was committed.

Third, a quiet one: the 360 recipe's quality knobs were HARDCODED, so SH_DEGREE, BRUSH_RES and MAX_SPLATS could not be turned even though they read like dials everywhere else. Asking 'how good a model can I get' had no way to ask for more. They yield to overrides now, defaults untouched — and the measured ablation stays in the comment above them, because densification saturates at 15k steps and 2048 resolution produced FEWER gaussians than 1280. More FRAMES is the lever nobody has tested. Also flagged and left switchable, not silently changed: the pipeline publishes a floater-PRUNED model as its deliverable, and post-training floater trimming is a thing he has judged worse twice. SPLAT_PRUNE=off ships the raw trained model for a side-by-side.

All five rows are gone. What replaced them is one TIMELINE row whose subtitle is the actual inventory — "3 walks · 41 photos · 10 videos · 1 note" — instead of a bare total. That breakdown is what the five rows were really for: a glance that tells you what the site holds. A single number 52 tells you nothing.

NOTHING WAS LOST, AND THAT WAS THE HARD PART. A sweep that quietly drops a capability is a feature deletion wearing a cleanup for clothes. So before any row came out, every ability it held moved onto the timeline: the walk row now carries its full set of facets (WATCH, SPACE, STILLS, and the one-at-a-time delete) exactly as the SCANS fold did; per-note and per-paper deletes ride their own lines in the day; and the delete-alls hang off the filter chips, where they still say the count out loud — DELETE ALL 41 PHOTOS — because an X standing for forty-one things must never read like an X standing for one. That control sits at the FOOT of the scroll, deliberately far from the filters: destroy is not a neighbour of browse.

With their doors gone, the NOTES and PAPERS faces became unreachable code — 129 lines of full-screen UI nothing could open. Narrowing the poolFace type from four values to one is what found them. They are deleted.

The TIMELINE row also shipped yesterday with no icon: the tone was new and the row-mark map was never updated, so the most important row on the card was the only one wearing a blank where every other row wears its kind. It has a calendar now, because the row subject is days.

The card HISTORY face is now: BAD DATA when the record is wrong, any walk currently in flight, TIMELINE, and the INDEX pass. Four rows, three of which are conditions rather than kinds. If a kind needs reaching, it is a chip inside the timeline — not a door beside it.

The cause is a single number written in August 2026 and never revisited. The card pile sizes itself by arithmetic: take the height of the screen, subtract what the print around it needs, and give the rest to the hero card. The amount reserved for that print was hardcoded at 36 pixels — true on the day it was written, when the print was two thin lines. Since then the margin has grown a claim door, two page doors, and ASK THE WORLD: about 155 pixels. Every one of them was budgeted at zero, so the pile took their space and drew over them.

Now the margin measures itself and reports its own height, and the pile yields exactly that much. Add a fourth door next month and the arithmetic simply knows — no number to remember, nothing to go stale. Verified at 360×640 and 390×844 in a real browser: no overlap at either size, and the hero card's tool list scrolls the way it always has when the card is short.

The two page doors also stopped pretending to be captions. They had been dressed to match the fine print around them — written down at the time as a virtue, 'so the sheet has one voice.' That was the actual mistake. A door that looks exactly like the caption beside it is not a door, it is fine print. DEV LOG and SHARE THE APP now sit below a hairline rule in the sheet's darkest ink, at the weight ⊕ ASK THE WORLD already earns.

Worth writing down because it is the second time this week a thing looked right on a laptop and was wrong on the phone the app is actually used on. A desktop window is not a test of a field app.

Then the wait, which was four things stacked: a 650 ms settle timer, a round trip to mint the window key, the world's own fetch, and the three.js + tiles bundle downloading cold. The timer is gone — replaced by a test of MOTION rather than time. If the pile has been still, you are arriving somewhere and the world lights immediately; if a card moved a moment ago the deck is still in flight and it waits for the deck to square up. Deliberate is instant, a riffle still opens one or two worlds instead of twelve. The key is now minted once per site and kept, so a card you have already held costs no round trip at all, and while you read the top card the app quietly warms the next card's key and the world's code — both free, neither touching Google, so nothing is spent on a card you never reach.

Measured on the harness: landing on a card went from about 1.3 seconds to 248 ms before the world starts; revisiting a card mints zero keys; a five-card riffle opens two worlds. And it arrives like it means it — the earth now fades up over the paper map across 900 ms instead of snapping in, opacity only, because a transform on a resting card is what made Android drop hairlines back in August.

Both fixed with anatomy the app already owns. The content pages now carry the SAME back chip the world viewer uses — a pill in the top-left corner reading ← APP — so leaving any surface looks like one gesture across the whole product; the nav tabs grew to readable size and the current one is underlined in the fire. And in the app's own bottom margin the doors stopped whispering: (DEV LOG) and (SHARE THE APP) now wear the margin's normal ink and its parentheses, exactly like (VIEW COLLECTION) and (CLAIM SITES) above them — one voice, three doors.

The operator card gained the row it was missing: SHARE THE APP, which copies the /get link straight to the clipboard and prints COPIED when it lands (falling back to opening the page where the clipboard is blocked). The build journal already had a row there; the link a person actually hands to someone else did not, so the one person handing it out was typing the URL from memory.

THE DOOR HAS A NAME NOW. A TIMELINE row sits above the per-kind rows on the card, in its own teal — the same survey colour the card art already draws this site ground in. It reads "Every day at this site — walks, photos, videos, notes, papers" and opens the whole record unfiltered. The PHOTOS, VIDEOS, NOTES and PAPERS rows were always filters on one face; what was missing was the door that says the thing itself. The face header now reads TIMELINE rather than HISTORY.

THE DAY HOLDS EVERY KIND. Notes and papers had been locked in faces of their own, where the day they belong to could not be seen — so a Tuesday showed its photos but not the note explaining them or the bid that arrived with them. Both APIs had been returning the timestamp all along; the card simply never carried it. Now a day reads 2 WALKS · 5 PHOTOS · 1 VIDEO · 2 NOTES · 1 PAPER, and notes and papers render as single lines above the photo grid, because they are one line each and burying them under a wall of squares hides them.

A note files under the day it is PINNED to, never the day it was typed — a note written Friday about Tuesday belongs to Tuesday. That distinction already existed in the data (day vs captured_at) and now the timeline honours it.

Six filters do not fit beside a site name on a phone, so they moved to their own scrolling line: ALL, WALKS, PHOTOS, VIDEOS, NOTES, PAPERS. A filter you cannot reach is a filter that does not exist.

AND THE PHONE WALKS TOO. The 360 VIDEO row now says "One walk — 360 camera or your phone." It always accepted either (the caller routes X5 vs phone and the user picks nothing), but a row named 360 VIDEO reads as "you need the $550 camera", and a walk you believe you cannot take is a walk you do not take. Still one row: naming both devices is not splitting capture back into per-device tools.

The fix was already written and had never once been called. WalkRelayService — 600 lines of native Android, hardware-verified back on 2026-08-07 — banks the camera H.264 stream into five-second chunks DURING the walk and uploads each one the moment it rotates, piling them on disk when there is no signal and draining them when a real network returns. /api/scan/submit already had the matching two-call contract waiting for it, with chunk_ext h264 hardcoded in the live branch: that branch was written for this relay. The worker already knew how to concatenate the chunks. Every piece existed. Nothing connected them.

So now REC starts the relay and opens the job immediately — the walk exists as a real row on the card the second you press record, not after the transfer. STOP finalizes it with the true chunk count and RETURNS. No confirm sheet, no SEND, no waiting: the record comes up about a minute later while you are already walking to the truck.

The confirm sheet has not been deleted, it has been made conditional — it exists because a walk used to sit unsent on a phone ("I cannot afford for this recording to be dropped"), and when the relay carried the walk there is nothing being held and nothing to drop. Where the relay does not run — old APK, refused start, failed submit — the classic download-and-confirm path is untouched, byte for byte.

The 5.7K master is not lost and never was. The relay copy is the camera preview stream: good enough to watch, index and answer from, but not the master the twin wants. So the master is parked as an OFFER instead of a wait — it stays on the SD card and gets pulled later on shop WiFi, where multi-GB over a cable-grade link costs nothing. And through all of it the walk is safe on the camera regardless of what the phone, the network, or this code does.

THE DAY IS THE SPINE, AND NOW THE WALKS STAND IN IT. The history already grouped photos and clips by day. Walks were missing from it — so the biggest thing that happened on a site was the one thing its day could not show, and a day holding ONLY a walk rendered nothing at all. Walks now carry a real timestamp instead of a printed label ("AUG 14" cannot be sorted or bucketed), so each one files under the same local day as the photos shot beside it. Day headers read 2 WALKS · 5 PHOTOS · 1 VIDEO. A walk renders full width at the head of its day with its length, its parking-lot verdict, and WATCH — a walk is not a thumbnail. There is a WALKS filter beside ALL, PHOTOS and VIDEOS, wearing the X5 purple the card already uses.

Why this and not a new feature: a place across days IS the product — "walk back into any day on site" has been the first line of PRODUCT.md since July. 4D memory is not a new data type and does not want its own row. Every capture already carries a day and a place; the timeline is a view along an axis that was always there, not a pipeline. And it is device-agnostic on purpose — a walk is a walk, whether an X5 or a phone shot it.

Measured end to end against the live APIs, standing in Rockville: 'lerner oxford square', 'lerner oxford', and 'lerner oxford square apartments' ALL return Lerner Oxford Square, 11902 Parklawn Pl, Rockville MD 20852 as the top result, 5.9 km away. '11902 parklawn' and 'rockville pike' still answer from the free stack alone. Four of six test queries spent a Places call; the two that were already working spent nothing.

Ranking got one more rule while proving this: a candidate carrying every word you typed outranks one that merely sits closer, so '600 rockville pike' returns the exact address above the whole of Rockville Pike. And the key: it prefers a server-only GOOGLE_PLACES_API_KEY, falling back to the existing 3D-tiles key with its allowed referer sent explicitly — our key, our server, our project. Places was already enabled on the account; nothing new had to be turned on.

They share a shell now — PublicChrome: the app's own paper, the Barlow wordmark over its fire rule (the card back's anatomy), and one nav row that always prints every door and inks the one you're on. The install page leads with a sentence about what the thing actually does before it asks for an install, and its buttons are the app's ink instead of a borrowed orange. The dev log stopped looking like a terminal and started reading like a field journal: serif titles, datelines in the fire, a hairline rule per entry, and its own count in the subhead (564 entries across 34 days).

The app carries the last span: two words of margin print under CLAIM SITES — DEV LOG · SHARE THE APP — set in the muted ink so the pile keeps the eye. Verified by walking it: app → dev log → THE APP → back on the pile, no dead ends. One thing deliberately NOT changed: /get is public and /devlog stays behind the password wall. The nav prints both regardless, because a locked door you can see beats a door you can't find — but whether the log should be public is a disclosure call, and that's Kymani's, not mine.

So the dead end is gone. When a search finds nothing, the field now offers the ground under your boots: USE WHERE I'M STANDING, with the real reverse-geocoded street address beneath it, as a one-tap elected candidate. The line above says why in plain words — the map has no place by that name, use where you stand and name the card yourself. That's the actual workflow for a jobsite the map hasn't heard of: the NAME is yours (Lerner Oxford Square), the ADDRESS underneath stays true (5901 Montrose Rd), and the pin is exactly where you're standing. The standing address is only fetched the first time a search comes up empty, so a field nobody struggles with costs nothing.

Found while proving it: OPENCAGE_API_KEY isn't set in this deployment, so the 'deep ladder' has really only ever been Photon then Nominatim — two views of the same OpenStreetMap. Worth knowing before anyone blames ranking for missing data again.

Two rules now. When a multi-word search finds nothing NEAR you, it retries with each word dropped in turn and merges what comes back — so an unknown word can't sink the search, and nobody has to learn which words the map likes. And nearness ranks the result: a jobsite is somewhere you can drive to, so a weaker match 3 km out always outranks a perfect-looking one in another state (past 300 km a result sinks below everything local). The extra calls only happen on a near-miss; a query that already landed nearby costs exactly one request.

Measured against the live geocoder with all three of his phrasings: 'lerner oxford' → Oxford Square, Hanover MD at 3.5 km, top of the list. 'lerner oxford square' → the same, plus The Yards at Oxford Square. The words he'd actually say now find the place he's actually standing in.

And the card shows the ground now. A complex the map half-knows is exactly the moment words stop helping and a picture starts, so the new-site form opens with a map of where you're standing, pin centred, captioned in plain words — YOU'RE STANDING HERE while the spot is at your feet, THE SPOT YOU PICKED once you choose somewhere else (distance decides, so the caption can't lie about a prefill you didn't pick). The site is born pinned to that spot no matter what the address bar says, which makes seeing it the confirmation.

THE BYTES NEVER GO THROUGH JAVASCRIPT. Reading a 500 MB walk into a blob would take the tab down with it. Instead the storage host is asked for an attachment directly (?download=<name>, which Supabase answers with Content-Disposition — verified against the live bucket by pulling a real 46 MB clip down intact). Note the download ATTRIBUTE alone cannot do this: it is ignored cross-origin, and our storage is cross-origin, so the file would just open in a tab.

And it works in the installed Android app, which was the part that could have quietly failed: an Android WebView ignores downloads entirely unless the app registers a DownloadListener, and ours does not. The native path streams the file to Documents through @capacitor/filesystem instead — already bundled in the APK, so this needs no new build; the JS ships from the server. The button says where the file went, because a silent success on a phone is indistinguishable from a dead button.

Saved files are named for the site and the moment: roadguard-interlock-2026-08-17-110200.mp4, not 1785694231089-x13ip8.mp4. A folder of them sorts into the order the work happened. Papers keep their own filename, because that is what the sender called it.

Three guards make that safe rather than reckless. Only the TOP card gets a world (a sleeve or a binder pocket never does — one GL context per pile, not thirteen), it ignites only after the card has SETTLED for a beat (a riffle throws a dozen cards through the top seat and each one would otherwise open a tile session, which costs real money), and the face is transparent-backed: the static map art stays underneath, so a card whose ground never streams looks exactly like it did yesterday instead of turning into a black rectangle.

And the second half, which was the louder complaint: "data is displayed on the live map just terribly — I wanted to find a specific photo and I had to go to the History section." He was right, and the honest answer is that a map is a bad file browser. SPACE ORIENTS, TIME BROWSES. The card face no longer prints the web of numbered tabs you had to tap at random (they stand down at card size; the full-screen world keeps them, and cited ASK evidence always shows). Browsing moved to the thing he said actually worked — the history — which is now ONE scroll instead of two: photos and videos together, broken by day (TODAY · 4 PHOTOS · 1 VIDEO), sticky headers, capture sets still bound, notes and marks under every frame, and ALL / PHOTOS / VIDEOS as a filter rather than a fork.

The black video tiles are fixed too. preload="metadata" fetches a clip's duration but decodes no frame, so every video in the history was an empty box; the media fragment #t=0.1 makes the browser seek to a real frame and paint it. Still no CDN call on an .mp4 — the browser is still the thumbnailer.

THE PHOTOGRAPH IS NEVER REWRITTEN. A mark is vector data filed beside the note, not pixels burned into the file — which is what makes the rest of his ask possible. "View them with or without overlays" is then just a switch that decides whether to draw them: MARKS ON / MARKS OFF in the photo viewer, in the world's memory sheet, and in the full-screen lightbox (where the marks zoom and pan locked to the print). The frame underneath is always the original evidence, and the marks stay editable forever.

AND THE MARKS ARE PART OF THE RECORD. A marked photo clears its own index stamp the moment it is saved, so it goes straight back into the pending pool — and when the eye re-reads it, it reads it MARKED: the frame is composited with its marks in memory for the length of one API call (never stored), so the model can see what was circled and say what each mark points at. His typed labels rank alongside pixel-read signage in both ASK and FIND, and the answer's reading of the marks rides on every evidence frame. Circle a breaker, label it DEAD LEG, and the record can be asked about it.

One deliberate omission: INDEX_V was NOT bumped. Marked photos re-read themselves; bumping would have re-read ten thousand unmarked captures for nothing.

Bound to options, and honest about it: only an elected candidate can ever become a site's address — enforced in the field, and on the server where it can't be bypassed. While what's typed isn't the bound address, the bar prints which one is real ('KEEPING 600 ROCKVILLE PIKE…') instead of silently snapping your typing away. Both address doors — the new-site form and the card's header line — are the same one component, so there is no second place to fix.

And the point clouds are OUT of the map, on his call: 'get rid of that stuff... I don't want it to bloat up my application, I'm not focusing on it right now.' Deleted, not commented — the in-world cloud layer, its lazy loader, and both API payloads that shipped it. The walkable viewer at /points/[id] is untouched and the scan beacon is still its door; the world is Google's earth plus his record again.

The x5-diag chip and the /x5-test page are deleted — the throwaway diagnostic that proved the X5 preview survives recording did its job, and its own header always said to delete it once the question was answered. The question was answered.

Proven against the live record before shipping: a real 900,000-point walk from the bucket, fetched, parsed, and standing beside its project's plate inside the world — actual walls, actual color, his data in his world. One honesty carried on its face: a blind solve knows scale and gravity but not compass heading, so a cloud stands at the pin with its heading unregistered until the TURN control lands — the next build, on the same pattern as every placement correction: the man who stood there is the authority. This is the memoria-loci convergence starting to be real — the world made of the record, not decoration around it.

The shot now composes only from beacons inside the same 20 km line the frame and the card art already obey; when a day has no in-sheet work, the opening holds home — the site pin is the door. Deliberate travel is untouched: the memory rail and the spots list can still fly to the far capture on purpose. The opening just never wanders there on its own. Computed against the warehouse's real row: the outlier sits 22.1 km out, the shot holds home, the world opens 150 m over the elected address.

The art now follows the law the live map learned yesterday: a pin beyond 20 km of the card's own pin still draws when it lands on the sheet, but it doesn't decide the frame. Lit ASK evidence stays exempt — a cited proof must never fall outside the crop showing it — and the z10 corridor floor is untouched (20 km of radius holds a 40 km corridor on the card). Verified on the harness with the warehouse's real coordinates: the art opens tight on the building, bullseye centered.

The fit now anchors on the site's pin — the address is the door — and takes every placed capture within 20 km of it; a farther spot still lives in the lists and the record, it just doesn't decide the camera. For the warehouse that means the world opens tight on the elected address instead of framing half of Maryland. One component, every door: the card portal, the share window, and the summoned world all read the same fit.

Three repairs, one principle — the elect is a refinement on top of the old self-addressing, never a replacement for it. The header prints the address whenever the card has one (only the legacy nickname-stamp stays hidden, told apart by the comma every geocode carries). The lazy backfill heals more shapes now: stamped nicknames re-derive from the pin, and a card with NO pin at all adopts its first capture's GPS — his words, 'where it first detected upload' — so no card can be mapless. And the backfill finally stops renaming nicknamed cards while it works.

One writer bug fixed with it: electing a candidate that lacked a city wrote city=null, which re-armed the backfill against the fresh elect. The pick now only overwrites what it actually carries.

Three viewer fixes in the same pass, all his: the date scrubber now steps ABOVE the ask bar instead of underlapping it (a bottomInset the mounting surface sets — card windows never had the collision and keep their layout). A new ▣ PRINTS toggle in the header raises every photo as its own tiny print on the land — the №-tab swaps for the thumbnail itself, same glove-sized hit box, same declutter ladder; press again and the tags return. Caught in verification: a span shown with display:'' is inline and inline ignores width — every print rendered as a one-pixel sliver until the toggle said block.

And the memory card shed its box: no panel, no border, no background slab — the photo floats with its own shadow, the label and the bonded note carry their own legibility with text-shadow, and only the true controls keep their pills. The world plaque steps aside while a memory is open, because two headlines in one column is one too many. Also rendered this hour, not shipped: three ways to put the earth in his hands — the ORB (a crystal-ball disc with a ground shadow), the ISLAND (terrain feathering into the paper on every side), and the PLATE (a tilted model slab) — waiting on his pick.

The dropdown is live now: candidates chase the keystrokes (debounced to one query per typing burst, verified on the harness), ranked by a GPS bias so the jobsite around the corner beats its namesake three states away. The terms line that shaped it: Nominatim and OpenCage both forbid per-keystroke use, and Photon (komoot) is built for exactly that — so live queries go only to Photon, and the ⌕ SEARCH press remains as the deliberate deeper reach through the full ladder. Typing '9207 51st av' now surfaces '9207 51st Avenue, College Park, MD 20740' before the address is even finished.

The x5-diag debug door no longer prints for signed-out visitors. It was standing on /get and /login for people who had never seen the app.

A fresh world no longer borrows the lab’s demo day labels — it was printing JUL 28, a day nobody captured. A record with no dated memories simply has no scrubber, and project name plates no longer count as memories in the day count or the debrief.

Asking an empty record answers instantly and teaches the next move, instead of spending nine seconds and an API call to say nothing.

/get stopped telling strangers to ask Kymani for the Android app, and its one door now says CREATE ACCOUNT too. The signup confirmation copy tells the truth: the link opens the app signed in.

The proof the loop works: the stranger account’s first photo and first note answered “where is the electrical panel?” with the note’s words and the panel label read off the photo’s pixels — inside its first fifteen minutes.

The dress is a prop, not a fork: dress='paper' on the home summon, while /world (the deep-link frame) and every site live map keep the classic dark window — one flyover, three frames, zero duplicated code. Verified in-browser: the ground floats with its ragged edge against the white, the fog band melts into the sheet instead of into night, and everything inside still works — plates, ask, scrubber, the accordion.

The law under it is fog of war, and it is deliberate: a jobsite record is a customer’s building, so foreign ground ships as GEOMETRY AND WEIGHT ONLY — position, extent, capture count, last-active. No names, no notes, no media, no ids, no doors. The privacy lock is the query itself: the server selects coordinate paths out of ai_notes and nothing else, so a stranger’s words never even enter the process. The camera still frames YOUR work — foreign ground beyond the metro stays over the horizon — and the flyover needed zero new rendering: claimed ground is claimed ground, whoever holds it. Today the earth holds one account; the moment the second signs up and claims, both crews see the world stop being empty.

Two doors, one component. The card header grew a slim address line under the title (front card only — the sleeves' one-line crown law holds), tap to search and elect in place; a card with no real anchor prints SET ADDRESS in working amber, so the couch-born card announces itself instead of hiding. And the new-site form's city line became the same picker — prefilled from GPS when you're standing there (press straight through, nothing changed), type-and-elect when you're not.

The elect rule is enforced server-side where it can't be bypassed: a write without a labeled candidate and finite coordinates is refused. The pick never touches the name — rename owns that — which ends the address doubling as the title. Everything downstream re-derives on its own; nothing else needed code.

One measured constraint shaped the geometry: the flyover collapses to its card-caption chrome below 340 CSS pixels of width, and an object with generous margins on a phone would cross that line — so the margins are exactly 12 pixels a side, which keeps the object in full dress on a Razr while still reading as a thing on paper rather than a takeover. On a desktop it caps at 1100 wide and floats centered, unmistakably an artifact on the drafting sheet.

'The labels look elementary school — uber large and distracting.' He's right: the tags were 20px candy pills with full-strength neon rings. Every tag in the world and the live map is now a 15px drafting tab — squared corners, hairline edge at half strength, smaller print — so three hundred of them read as annotations on the land instead of confetti over it. The project name plates traded their 700-weight badge armor for tracked caps on dark glass, two pixels taller than a № and no louder. The 46px glove hit boxes are untouched everywhere: only the ink shrank.

The loci-lab now feeds demo zones to the flyover — one around the field, one tiny far one proving the size floor — so the boundary work has a test bed that needs no live data.

'Remove the boxes around the arrow buttons, make them more centrally aligned' — the bordered edge-tab died the day it shipped. Bare printed chevrons now, centred in the same 56×128 glove box: type on the page, not a widget on top of it.

'Remove the coordinates from below live map' — the 38.9800N · 77.0900W microprint is gone. The teen-test law always said coordinates are for the math, never the reader; that caption was the last place they leaked into ink. ROUTE keeps them in its href, where they belong.

This is the one-world-two-frames law finishing its arc: SiteWorld taught it at card scale (the card mounts the world directly — no iframe, no second app booting in a box), and the account's globe now obeys it at home scale. /world survives only as a thin deep-link frame around the same canvas, so a typed URL or an old link still lands somewhere true. Verified in-browser: summon over a pile, the full experience standing (ground, plates, ask bar), fold — cards untouched beneath.

Second: 'enable zooming into the jobsite — as of now we need to click to enter them.' Zoom is a door now. Diving the camera into a project's ground opens it, no press needed; pulling far back out folds the world to plates. The hysteresis is wide — open near the project's own working height, close only at a third of the world's span — so orbiting inside a job never flaps, and the plate press still works and still outranks it. Found and fixed underneath: the camera's descent floor scaled with the raw span, which on a 120 km account meant you could never get below ~14 km — 'entering' a jobsite stopped in the stratosphere. Project worlds keep a 120 m street floor now.

Third: 'remove opening photos in separate tabs — when I open a photo it should show its full size, zoomable and all, in app.' The last browser tab in the product dies: OPEN THE PHOTO raises an in-app lightbox — full-bleed print over the dimmed world, wheel and pinch zoom about the point under your fingers, drag to pan, tap the print to jump between fit and 2.5×, tap the dark to put it down, the bonded note riding the foot. Only papers (PDFs the browser must render itself) still leave. All three verified in-browser end to end: fills on first look, wheel-dive auto-opened Purple Poles and zoom-out folded it, the lightbox zoomed anchored to the cursor. On the it-can-wait list, his own words: the viewer's overlapping overlay elements — 'let's keep it simple for now.'

Second: 'remove the daily tracking feature, monday through sunday with the orange fillers — simply unneeded and useless.' The week strip — the S·M·T·W·T·F·S depth dots, N TODAY, the streak flame — is deleted, one day after the Daily Draw and the Hand died and for the same reason: gamification on a work card. With it went the whole feed: the 7-day pulse stream and the 90-day streak query, which were two full captures-table sweeps on every home load. The tools face opens straight onto the rows now, and /api/sites got measurably lighter.

Verified in-browser on the harness: three stubbed cards, forward arrow surfaces №02, back arrow returns №01, back again wraps to №03, and the card face holds six plain rows with no strip.

This is the third time an ask surface died for the same law (the summoned ask card, then the in-card ask face, now the home bar): one ask per scope, and the surface is always the map that lights the proof. A site's questions live in its live map; the world's questions live in the world.

Verified live: a persisted last-site hydrated on load, printed LAST SITE one card deep, and summoned its card to the front on tap — after which the tab stood down, because a bookmark for the card in your hand is noise.

Fixed at the definition: a walk becomes a beacon the moment it is WATCHABLE — a footage URL in stats, the same test home's footage door uses, published by the stitch about a minute after upload and long before done — and its door is /watch, the in-app 360 player. The verb says so: WATCH THE 360 WALK. Points-only phone bundles keep their /points door (done alone lies — a bundle is done with no footage, and its /watch would be an empty player). Verified against the real record before he left: the live DB's footage walks resolve to /watch, the point bundles to /points, and the deployed map hands the walk to the player in one tap.

Then the audit he asked for — 'view my entire application end to end, find redundancies, confusion, polish.' The codebase came back cleaner than expected: no console noise on home, no hydration warnings, no stale imports of anything deleted, no TODO litter. One real corpse found and buried: ASK's evidence contract was still minting /photo3d?sog= links — a route deleted three days ago in the 3D-photo purge — so an old capture's receipt could open a 404. The branch is gone; receipts fall to the photo itself. Flagged for later, not fixed here: /world's beacon mapper is a hand-copy of live-view's (drift risk — reconcile into one shared mapper), and the card-lab workbench carries a type error owned by the other bench.

His open invitation — 'anything you want to do, optimization or UX wise?' — got two: /api/sites used to fire FOUR batches of per-site count queries on every home load (fifty-two round trips for a thirteen-card field); it's ONE paged sweep now, classifying every capture in JS with the exact same grammar, verified row-for-row against the old queries on live data before shipping. And the footer's claim line printed 'CLAIMED AUG 14 20…' — truncated on his phone's own screenshot — so the year went two-digit: CLAIMED AUG 14 ’26. A cut-off date is worse ink than a short one.

Two more debts paid in the same pass. Chips can no longer climb over the title: the tag ladder's ceiling was a guessed 56 pixels while the full-screen plaque stands ~150 tall (his phone screenshots had №-chips over THE WORLD's own name) — the ceiling is now the plaque's measured edge, sampled on the ladder's own 90ms cadence, never per-frame. And the twin beacon mappers are reconciled: live-view and world-view carried deliberate copies of the capture→beacon mapping for one night while both lanes were hot, and they drifted within hours (live-view dropped word-tags when №s won; the world's copy still shipped them as dead payload). One mapper in lib/beacon-wire now, called by both routes — a beacon means the same thing at every altitude by construction. Also settled, his call: it's ASK THE WORLD, not ask YOUR world — 'the world implies objective data outside of just yourself.'

What remains is the card at its Ive-simplest: the week strip, then six printed rows — pip, name, damage count, chevron, hairline — with ASK seated in rose at the foot, on the longer 6:11 cut with the art holding the LIVE MAP door. Zero scroll, measured. The HAND survives exactly as asked — one ⌒ tap at the strip's end fans the same tools, ▤ STACK brings the list back, the choice remembered. Verified live end to end: no DRAW anywhere on the face, the fan answers its glyph, and scrollHeight minus clientHeight still reads zero.

And his first act under the lock was a merge, not an addition. Looking at the home sheet's two stacked doors he saw they were one thing wearing two names: 'the record and the world are the same thing — the world is just the visualization of all of your records. Imagine if it said ASK THE WORLD.' It does now. One printed line where two stood: ASK THE WORLD raises the bar over everything you own (its placeholder asks your world, not your field), and past a thin vertical rule, ⊕ VIEW opens the world itself. Same corpus, two verbs — ask it, or look at it.

Press a plate and that ONE project opens: the camera flies to frame its ground, its memories stand up — folded into their own spots, the inner accordion starting fresh — while every other project stays a plate. Press another plate and it switches. Press the OPEN project's plate again and its door card deals (ENTER THIS PROJECT). Tap bare ground and the world folds back to plates at survey altitude — the same close gesture the spots taught, now closing the level above them. Every beacon rides a `site` id so the world knows whose memory is whose; plates ignore the day scrubber entirely (a project is navigation, not an event). Site worlds hold no plates, so none of this touches them.

Verified in-browser against a three-project fixture with one project 58 km out: first look shows all three plates and nothing else, pressing PURPLE POLES opened only its corridor, pressing GLEN BURNIE switched (poles folded back to a plate mid-flight), bare ground returned the survey. The one honest unknown is Google's ground at ~130 km survey altitude over a wide account — streamed fine at metro height; the wide frame gets its first real look on the phone.

The room came from the card itself, exactly as he asked: the cut stretched past the tarot 7:12 to 6:11, and the caption panel's fixed share of the face grew from 49% to 69% — the art yields but keeps the LIVE MAP door whole. The pile's width-from-height math, the pocket bodies and the create card all moved to the new cut together so no surface disagrees about the card's shape. Measured at card size: scrollHeight minus clientHeight is ZERO with all six tools, the strip and the deck standing in the face. Row height rides the card's scale (a full-width row a hair under 44px is still a whole-thumb target — the glove law's spirit kept where its letter couldn't fit six rows).

Second, the blobs: beacon geometry scales with the field so it stays legible at site size, but at a 20 km world that rule made every marker 66× — orange weather over Bethesda. Geometry now caps at 6× (SG) while the tags carry identity past that. And the night's second lesson, caught because the first fix went too far: fog, the camera's far plane, and travel distances must KEEP the uncapped scale — capping them put the far plane at 3.9 km under a 9.6 km composed shot and the entire world vanished beyond the clip. One scale for what things ARE, another for how far you can SEE.

Third, the soup: at world span the spot-clustering arm stretched to 300 m, single-linkage chained the whole purple-poles corridor into ONE knot, and a single tap unfolded 150 chips over the title. The arm caps at 80 m — knots stay at a size a dive can actually spread — and with the accordion's nothing-opens-itself law the default view is folded chips and name plates. Verified against a dense 60-capture corridor fixture: folded to one chip at rest, the fan opens only on a deliberate dive, PURPLE POLES stands legible through all of it.

And the Daily Draw found its true home: the deal lives IN the stack. The dealt tool's own cell wears the card back — the T, the fire rule, DRAW — until you turn it, then seats face-up in its ink, pressable through the one law. No extra row, no slab: the 123px face holds the strip and six cells, nothing else, so the draw borrows the cell it was always going to point at. BEST dropped off the strip (one line must hold in 226px; the record-to-beat can return on a wider surface) and the STACK·HAND toggle folded to one glove-padded glyph at the strip's end. The HAND survives whole behind it — deck-beside-fan, one word away. Verified live: scrollHeight minus clientHeight equals ZERO, every tool name prints full, the turn seats SCAN in its purple, and the footer's FLIP row never leaves reach.

Turning the deck plays the game's grammar all the way through: the top card flips (the 2D turn), the deal stands face-up ON the deck in its tool's ink with PLAY › at its foot — and the dealt tool LEAVES the hand, because it is on the table now; the fan breathes wider by one card. Pressing the deal goes through the same one press law as everything else: PHOTO fires, SCAN prints START? first. Verified live in-browser at card size: the zone measures scroll-free, the blank NEW SPOT card seats the same table with CREATE in its hand, the real card dealt WALK IT off its true walk age with the reason printed on the table line, and the footer's FLIP row stays in reach the whole time.

Then the hunt: even at sane altitude his ground stayed black, and every signal said deploy regression — until a clean browser against the same prod URL streamed the full Google tileset instantly. Prod was healthy the whole time. His own Chrome's ad-blocker eats tile.googleapis with ZERO console errors, which reads exactly like a broken deploy. Verified the real thing end to end in the clean browser: Bethesda Purple Line in full photoreal dress, memories standing on it, zones riding the land. The lesson is now code: the tiles-init catch — which swallowed 'no key' silently and let the hunt run for hours — names its reason in the console. A black ground must never be mute.

Housekeeping from the same trail: NEXT_PUBLIC_GOOGLE_3D_KEY was never in .env.local (localhost threw 'no key' before the referrer lock ever got a say) — it's there now; it is a public client key, inlined in every visitor's bundle by design.

The lines obey the two hard laws of this ground. They ride the measured frame — re-seated and re-yawed from the tileset's own east vector every pass, never a hardcoded flip — and they stand at the average solved ground of the beacons inside them, the same honesty the spot rings learned when they floated onto roofs. A rectangle is also 180°-symmetric, which means even the half-turn cannot misplace one. Verified in-browser against the two-project fixture: the corridor box frames its whole run, both zones ride the land, the day machinery unbothered.

And the chips slimmed down (his words: 'so large and gaudy, though I understand accessibility'): the solid paper block became the № tag family's own dark glass with a paper edge, 20px tall, one size up in voice rather than armor — while the invisible 46-pixel glove target underneath didn't move a hair. Accessibility was never the visual's size; it was the hit box's, and those were always two different things.

THE STREAK joined the week strip: consecutive days the operator documented ANYTHING, anywhere in the field — global on purpose, because nobody visits one site daily; the habit being burned is 'documented today'. It prints as the flame with its count and the record to beat (7 DAYS · BEST 11), fed by 90 days of real capture stamps shipped raw and bucketed into the viewer's local days — with BOTH edges of every UTC day aboard, so a timezone can never falsely break a run. A run unfed today still stands; today's fire ring is the invitation, not the failure.

THE HAND: the tools' second presentation — LIST · HAND, two quiet words above the rows, the choice remembered. HAND fans the same tools as a held hand of mini cards, each wearing its pip, its name up the card, its count in the corner. Taps only, no flick physics: tap lifts a card from the fan (the free fidget), tap it again and it presses through the one law — which now literally is one law: pressTool, extracted so the row, the dealt card and the fan can never drift apart. The binder's pocket minis never fan; their one tap must draw the card. Verified end to end in a live browser: the blank card dealt CLAIM IT, the real card dealt WALK IT off its true walk age, PLAY armed to START? and lawfully expired at exactly 3.5s (the recorder proved the window to the frame), the fan lifted ASK with its rose ring. One honest debugging lesson kept: every 'the arm is broken' observation was a probe slower than the 3.5-second law — measure with a recorder, not a glance.

Third, rings on roofs: a spot's ground circle had its height set once at creation and never touched the terrain again. Its members ARE terrain-snapped (and roof-nudged off structures) — so the ring now rides their average ground every pass, re-seated through the measured frame like everything else. Fourth, his best line of the day: 'in a way, Maps 3D tiles ARE 3DGS scenes — why not place the user in the most convenient zoom and orientation?' So the world opens PRESENTED now: the camera frames the picked day's work, turned so the work's own axis lies across the screen (a corridor spreads over the frame, not away from it), at the height that fits its spread — and turning the date picker is a cinematic cut to the next day's shot. Free roam survives whole; the composed shot is where you start, never a cage.

BAD DATA had to be re-ruled with it, because 'far from the address' now just means the project grew. The stamp fires only for the real failure shape — a capture sitting at ANOTHER card's front door while beyond a mile of its own (the Olney day that was really Glen Burnie). Filing far on purpose is the deliberate act that grows the ground: the card's armed ADD line says so ('add here? Its ground grows to you'), and a no-match claim batch now keeps its files so the receipt can offer one tap — FILE THEM TO PURPLE POLES, ITS GROUND GROWS TO THEM — instead of dead-ending. Never silent: a quiet auto-extend is how one stray photo teleports a project to Virginia.

And the card face tells the truth about how far the work reaches: the map morphs to fit the whole territory (the zoom floor dropped from neighborhood to corridor scale) and a teal dashed perimeter — a plat line, the one mark on the card wearing that ink — boxes the furthest data points. Then the door he asked for outright: ⊕ THE WORLD, printed under ASK THE RECORD, opens /world — every project standing at its address on the real earth, every placed capture as a beacon, one shared timeline across the whole account, each project beacon opening its own live window. Verified in-browser against a corridor fixture (morph, perimeter, world boot, spots folding); the Google 3D ground streams only on the deployed URL by design, so the globe's full dress gets its look after this deploys.

On the real pole card that yields CABLE, ROOF, BUCKET, UTILITY, and honest bare counts where nothing distinguishes a knot — a spot that can't say something true about itself says its number instead. The stoplist and thresholds are written down as measured values, not taste: re-measure against a real card before moving them. Built and verified entirely in the tradesman-b lane while the main tree stayed busy — the two-cutting-boards rule, hours old, already paying rent.

Two more turns from the pitch landed with it: the damage numeral now wears its tool's own edge ink (28 in photo amber, 3 in scan purple — the card reads like a printed spread of suits), and ASK sits at the card's foot in its rose seat permanently — the one solid object on a face of printed lines, same visual grammar as the armed beat so there is nothing new to learn. The data is honest end to end: /api/sites ships each card's last-7-days capture stamps RAW and the card buckets them into the viewer's LOCAL days (a 9pm photo is today's work, whatever UTC thinks); machine frames and walk stills are excluded — the pulse measures the tradesman's labor, not the pipeline's. Scans join client-side from the card's own jobs. Verified live in-browser: the rich Monday prints big, the empty Saturday prints a ring, today's fire bar tips the PHOTO pulse, and the blank NEW SPOT card wears the same strip with honest rings — no card is different.

Crowding law held the line on what did NOT ship: no second text line returned to the rows — the pulse is ink, not words, and it rides inline. The week model computes after mount only, because the server pre-renders in another timezone and day letters that flip on hydration are the glitchy-app bug wearing a new hat.

Second, ASK stops hiding in the history tab. It was seated as the head of the HISTORY page — a tool living inside the record it reads. His call: 'remove ask from the history tab, put it on the main card tools face.' So the ADD face is THE tools face now — every move on one page, capture moves first, ASK at the foot with its count — and HISTORY is purely the record. ASK's tap is unchanged: the live map opens with the ask bar armed, the world answers. Verified live in-browser: a real card printing ADD 6 with ASK · 8, the history face holding only PHOTOS and NOTES, and the blank NEW SPOT card mirroring the same anatomy, as the law requires.

Verified in the lab against a second demo knot: both spots folded from altitude; diving PANEL opened only PANEL — METER stayed a bubble, standing off-frame in the edge nudge's count (◀ 3: one loose note plus two folded meter shots), which is the folded-tally law holding through the new behavior. The card-sized glance is stricter still: nothing opens but an explicit dive.

Beside the input, one word cycles the arrangement: ALBUMS (the resting binder — projects as albums), LATEST, NEAREST (when your location is on), CLAIM №. Any search or non-resting sort flattens the binder to one honest list; clearing puts the albums back. Android back peels in layers — first the typed search, then the sheet. The empty state says what it did: 'No card matches — checked every name and every record.' Verified in a live browser with the fake-cookie harness: name filter to one pocket, the record chip on the right card, all four sorts in order, the empty sentence. Found and fixed while building it: the map FIND's haystack was joining label OBJECTS into '[object Object]' — photo label text was invisible to the map's own search. Both finders read the printed characters now.

The history face got the same lesson in one line: on a desktop its grid used to stretch wall-to-wall; width past a readable page is margin now, not more columns.

The beautiful part is the bond. A clip's timestamp notes — the moments the tradesman marked WHILE filming — are fed to the read with the pixels, and each frame near a tnote carries those words as its own note, ranked in retrieval at the exact second they were said about. Proven live on the first run: the two real clips in the pool produced 19 frames; the tnote '2508' rode frames 0–6s and the vision read CONFIRMED it off the pixels — '2508' printed on the meter head — and '2386' the same on its cabinet at 28–32s. Ask where 2508 is and the record now answers with the frame that proves it. Frames carry video_id, never job_id, so no surface ever builds a /watch link for footage /watch cannot play.

One thing the re-read must never do is lose a character: the box read each frame at tile resolution (full frame plus four native-res quadrants), while the web pass sees one 2048px JPEG — so labels and text_seen UNION with the old read instead of replacing it. A panel ID the tiles caught survives a lower-resolution second look. And claimed phone videos stay out of the image reader on purpose — their frames wait until a real video eye exists; their typed notes already answer as text.

Second, FIND grew its JUMP-LIST: every match prints as a row under the input — №, the note in the operator's words, its day (green when it is the day on the land) — and tapping one flies there and opens the memory, turning the picker first when the match lives on another day. The finder stays up, so working the matches is tap-look-tap-look. Third, the CARD WINDOW became a true GLANCE: at card size the spots stay folded, always — named chips and honest counts instead of tag soup in a 300px box, the full workspace one EXPAND away — and the roster stopped being its own coagulation: memories that share a spot read under one named header, ◈ PANEL · 3, members indented beneath, singles loose, the calendar still the spine. Verified end to end in the lab: the named chip, the grouped roster, a cross-day jump that turned the picker and opened the memory, and the folded glance at 320px.

The mechanics: placed captures union into spots by arm's-reach distance (scaled gently with the field), each spot draws one quiet paper ring around its knot and one solid paper chip carrying the count — heavier than a № tag on purpose, legible from any height. The chip's count obeys every standing law at once: date-bound to the picked day, growing with the hour scrubber, and lit by FIND (a filtered spot counts its matches and dims to embers at zero). Tapping a spot dives to it and holds it open — the hold releasing only when the camera is told to pull well away, because big fields pin the minimum altitude above the natural unfold line (found and fixed in verification: the first cut released the hold during the approach, and the second follow-up made the whole cycle prove itself — folded at start, unfolded after dive, re-folded at home). Folded members stand down completely: no tag, no geometry, no raycast, but their spot still counts toward the edge nudges, so 'this way, 12 more' never lies.

Found while building it, fixed with it: the flyover's WASD listener was global, so every 'w' or 'a' typed into the ask bar, a day-note panel, or the new finder was ALSO a flight command — the camera strafed while you typed. Words go to words now. And the frames question that came with the complaint got its answer as architecture, not code: the card window is a GLANCE (proof the world is alive, a door), the full-screen world is the WORKSPACE — which is why FIND prints only there. Neither replaces the other; they stop pretending to be each other.

The engineering that makes it honest: Supabase's TUS endpoint was probed live — deferred-length creation works, small mid-stream chunks work, and write-authorization is decided at session creation, so the server mints the session (owner-checked, path server-chosen — the exact trust shape of the signed PUT it replaces) and the browser drives the PATCHes with the public key it already ships with. The pump is strictly sequential, holds the newest chunk back so the final flush always has bytes to declare the total length with, and on a failed PATCH asks storage where the offset truly is, drops what half-landed, and retries. Five straight failures mark the stream dead — and the chunks were kept locally the whole time, so BANK falls back to the classic whole-blob path and no take is ever hostage to the stream. Re-shot and abandoned takes discard their streamed bytes; nothing orphans. And the bitrate came down 8→5 Mbps: pole tags and panel labels still read, and every take is ~40% lighter everywhere it travels.

When the clip banks, its marks become the FOOTAGE TRACK on the live map: each ⚑ a real point on the ground it was pressed over, joined in shooting order by a line in the video's own ink (#FF7A3D — the color law holds even for paths). The track is not a set of beacons — marks are moments inside ONE capture, so they carry no № and never touch the plaque's counts — but it obeys every law the beacons do: date-bound to its video's day, riding the measured ground frame, heights sampled by the same budgeted terrain tick. And within the day it GROWS with the hour scrubber — each mark appears at shoot-start plus its seconds in — so scrubbing, or the DEBRIEF, literally replays the walk the footage took. Tapping any dot opens the video it belongs to; the visible dot stays small so the path reads as a path, but the tap lands on an invisible sphere three times its size — the gloves law, now in three dimensions.

Second, his exact words: 'I see a quantity count but don't know where to view.' A count with no door broke the row's own law — inventory AND action, one line. Day notes now have their reading room: a NOTES row in HISTORY (paper ink, same fold anatomy as every data type), opening the same full-screen face photos and papers deal — each note printed whole beside the date it is pinned to, never truncated, with an armed ✕ per note (ownership- and kind-scoped server-side, ids only — the live-DB law). Verified on the real card component in a throwaway lab route before shipping: five moves scroll clean, the NOTES face reads both Bethesda notes in full.

Two doors, one row. The card grows a NOTE move in ADD (paper ink, matching the flyover's note beacons — the color law holds): a two-field sheet, WHICH DAY and THE WORDS. And the live map's timeline grows ✎ NOTE beside the date picker: the day is already chosen — it's the day the map is standing on — so only the words are asked for. Where it lands is everything already built: the date-bound map files it under its day, the roster lists it, the DEBRIEF replays it with the rest of the day's story, and ASK reads it with the whole record — the corpus already takes every captures row and reads media-less ones as notes, so the analyze-everything law covered it before it existed.

And the first one is real, filed to Bethesda Purple Poles for today: 'We need to use THWN or XHHW, not low smoke — price impact.' The kind of sentence that costs money to forget, now standing in the record.

Three changes, one principle — a pin's place on the ground is decided by the record, never by the viewer's motion. Solves and height samples now spend SEPARATE budgets, so no pin can starve the tick. While any pin is unresolved the tick runs fast (300ms) whether or not the camera moves — the card settles completely in a couple of seconds, before a hand reaches the controls. And the measured-frame guard now calls 'changed' only what IS changed: a convention flip moves the origin by whole metres; streaming refinement wobbles it by centimetres, and re-solving every pin over that noise was pins wandering mid-use. Once a pin stands, its ground position never moves again.

Now every memory wears a surveyor's mark, painted on the ground and through everything: depth test off, so a roof, a tree, or the terrain's own slope can never eat it — you always see the circle, even when the spot stands behind a building. Three parts, each in the memory's own ink: the DOT (the capture's exact point), the RING (the little circle, crisp from altitude), and the HALO — the phone's own accuracy radius drawn in real metres when it's known, never scaled by the field, because accuracy is a measurement, not a style choice. The error-bar law again: an overlay can't be honest without it. Fly-to lands at 42m instead of 55·S, so going to a memory puts its circle unmistakably underfoot, and when ASK cites a capture the whole mark ignites green with the head — the proof is a spot on the ground, not just a head in the air.

The second half was subtler: a banked clip WAS saving to the card and map — the database had it — but the screen didn't. The card caches its pool list after the first open, and the art's pins load once at launch, so a fresh bank was invisible until an app reload. That reads as 'the video didn't save,' and a record you can't trust to show what it holds is not a record. Now every bank lands visibly the moment it succeeds: the count bumps, the clip's orange dot is inked onto the card art in place, and the pool cache drops so the next open (or the open face itself) refetches. Photos got the same fix — the camera sheet had the identical staleness. The toast tells the truth about the map, too: banked with a fix says 'standing on its map'; banked without one says so plainly, because a silent absence is the kind of lie this app exists to end.

Second, the ask found its true surface. The masthead ASK overflowed the new-spot card's back — Kymani saw the overlay and called the real fix: 'maybe ask should only be in the live map... the static one that shows answers should be gotten rid of.' So CardAsk — the in-card ask face — is deleted whole. The card's ASK row opens its own portal with the ask bar armed and focused; the share window and the card now ask through the same single AskSurface; and when an answer lands, its evidence ignites the world's OWN beacons — heads swell and go you're-here green in the flyover, one recolor pass per question, zero cost per idle frame. The proving spots aren't a second rendering of the map anymore. They ARE the map.

Third, the new data type: plain phone video, ushered in end to end. The card grows a VIDEO tool — the phone's own camera records (native stabilization beats anything we'd rig), and the clip banks on the same signed-PUT rails claimed gallery videos already ride, pinned by the live GPS fix and timed and measured by its own container (the mvhd box gives up duration for free). VIDEOS is its own drawer in the history — its own row, count, and full-screen face of player frames with lengths — because a clip must never masquerade as a photo. Inside the player: MOMENTS — timestamp notes. Tap ＋ and the note pins to the second you tapped; tap a moment's time and the player seeks there. Typed for now — the voice era stays deleted.

Fourth, the color law extended and the leaks plugged. Video wears #FF7A3D everywhere — the flyover already did; now the card art's dots do too (never thinned into a photo's amber), and the card rows wear the new CLIP ink. And the audit the new type forced found four live defects: the index pass was burning three guaranteed-failing Haiku calls per video (mistaken for an image), ASK would 400 an entire question if a video won an image-evidence seat, videos were inflating PHOTO counts, and a claimed clip could become a card's cover as a broken pane. All four fixed. The record now holds four kinds of memory — stills, clips, papers, walks — each in its own ink, all answering to one question bar in the world.

Second, the janky viewer. His words: 'data type rows that open as drop downs super tiny in the card... it's the users data history so it's important to keep accurate and optimized.' He was right — the folds crammed a photo grid into a 280px card. PHOTOS and DOCUMENTS now deal a full-screen HISTORY FACE, the same move the ask face and the print-in-hand viewer already make: full-size prints with the note bonded under every one (NO NOTE said plainly), the shutter instant on each, sets still sleeved together, the wrong-card prompt at the top when the detector has news, and every tap landing in the viewer that already works. The tab itself is renamed HISTORY — his word ('history or data'), and the honest one: VIEW named a gesture, HISTORY names what is actually there.

Third, ASK. His instinct — 'ask could be maybe like a global card button... ask and view don't belong exactly in the same place, though they kinda do since the history is what even allows anything to be asked' — resolved by honoring both halves: ASK left the section rows and sits as the card's masthead, above the rail, in reach whichever page is open, with the HISTORY it reads printed directly beneath it. The card is the overarching ask surface; its crown move no longer hides behind a tab.

Four: the tag ladder — sort plus collision negotiation for every label — ran sixty times a second, and rung assignments flapped, which reads as UI jitter. It now thinks on its own ~90ms beat and remembers each tag's offset (keeping its old rung whenever still free, so labels stop trading places); each frame just glues tags to their pins and skips the DOM for anything that moved under a third of a pixel — a settled scene writes nothing. Five: the compositor was re-blurring every backdrop-filtered pill and plaque each frame the canvas changed underneath — every blur in the world is gone, replaced by a touch more ink, and the full-screen pixel ratio cap eased 1.75 to 1.5 (~36% fewer pixels; the imagery is photographic and reads the same, the tags are DOM and stay crisp). The tile scheduler itself was NOT touched — errorTarget stays constant; that lesson (2026-08-11, the black world) is paid for.

The install is a window onto prod, which answers the founder's hard requirement — everyone operates on the newest version, always. The homescreen icon and the APK both load the live site on every open; a push updates the whole fleet at next open, and the service worker was verified network-first on pages so caches only speak when the signal dies. Accounts stayed exactly as simple as they were: the product is free, signup is open ('I want the world to for free conquer itself with data'), and every account's record is already walled to its owner server-side. The password wall that guarded the unfinished app comes down — /get, /login, and the install files now stand outside it, and real data was never behind it anyway, it was behind the account.

And the memory sheet stopped eating the world. It was an opaque slab: the photo letterboxed on a black fill, a full-width MOVE bar, a second row of buttons — tap a print and the land it stood on was gone ('so much blank black element... we wanna see the map at all times'). Now the photo draws at its OWN shape — the element IS the photo, no black bars — the ink sits on a translucent pane the map reads through, and MOVE folds into the one action row as a single word (the tap-the-ground banner already carries the how-to). Every target keeps its 44 glove pixels; everything else pays rent or leaves. The debrief sheet wears the same slimming, because the two are twins.

Nothing here is a new surface, which is why it fits everywhere the world already lives — the card's window and the full-screen share link both got it for free. It is the date picker, the scrubber, the fly-to and the memory card, put in a row and handed a NEXT button. Turning the date picker mid-replay ends it on purpose: a debrief is bound to ONE workday, never allowed to leak across a date line. And tapping any beacon mid-debrief answers the room's question on top of the story without losing its place.

Now it does: the no-location line names the cause (messaging apps strip it) and both fixes — ask for the photos sent as a DOCUMENT (WhatsApp keeps the original file byte-for-byte that way, location and shoot time intact, and claim then files them to the right card's mile on its own), or use UPLOAD on the card to file them by name, unpinned but on the record. Same law as every failure in this pipeline: honest, and actionable, or it isn't a receipt.

The live map's clock had a lie in it: the scrubber showed everything UP TO a moment, so yesterday's beacons stood beside today's, and days themselves were cut at UTC midnight — an evening capture filed under tomorrow. Kymani's word for the fix was 'vital': the map is DATE-BOUND now. A date picker steps across the record's real capture days — grouped by the calendar the viewer actually lives in — and the land shows THAT day's memories, nothing else's: they don't render, don't tag, don't raycast. Within the picked day the hour scrubber survives, because a field day is still a sequence of hours. Nothing is hidden by this: the ALL roster keeps every memory on every day, and opening one from another day turns the picker to that day first, so the land you fly over is always the day the memory belongs to.

The detector goes one step further than pointing: it takes the strays' centre and measures every other card's pin against it, and when one stands within the same kilometre it names it — THEY MATCH GLEN BURNIE HIGH SCHOOL, MOVE THEM — so the whole misfiled day comes home in one tap. When no card matches, the prompt opens the picker scoped to just the far photos instead of guessing. And it only ever prompts, never acts: a photo shot at the supply house and filed to the job on purpose is filing, not a mistake. The kilometre is deliberate slack — a big campus plus weak GPS never trips it; sites in this workflow are miles apart, not blocks.

The repair lives where the photos live, in two sizes. The pool prints one quiet underlined line above the grid — WRONG SITE? MOVE ALL 11 — that unfolds into the names of the other cards; tap one and the whole batch walks over, counts staying honest on both cards without a refetch. The photo viewer carries the same line for one print, because sometimes only a few strays are misfiled. The server side is the same PATCH that keeps notes, grown a second shape: ids plus toSiteId, guarded on BOTH ends — the captures must be yours and the destination site must be yours, so nothing can ever be filed into someone else's record.

The pairing is by language, not by drawer, because the two are different verbs. LIVE MAP is you walking in. LIVE LINK, in SHARE, is the same world handed to someone else — and it now says so in as many words: 'the same live map, handed to anyone.' One world, two doors, each on the section that describes what you are actually doing.

Nothing was invented for the sections: every row already existed, they were only in the wrong drawer. The punch-list door moved out of the settings menu, where a document deliverable had no business hiding, and onto the section whose whole job is handing work to someone else. Verified on the real Bethesda card: ADD 3, VIEW 3, SHARE 2, each section printing its own rows in the card's one row anatomy.

The first run was WRONG and that is the important part of this entry. Twenty-two of twenty-five headings named a pole that no note mentions: the model had read the citation markers as asset numbers, so photo [C20] — whose note plainly says Pole 12 — became 'Pole 20'. Three changes, because accuracy cannot rest on a prompt alone. The marker no longer looks like an identity (it reads '(photo 20)'). The rules now say outright that a photo number is not an asset number and that a heading may only name what a NOTE names. And the server checks: a heading carrying a number that appears in none of its own sources is replaced by the note's own words or dropped. Re-run on the same card: thirty items, zero unsupported headings.

One more truncation caught on the way: at the first ceiling the document was cut mid-JSON and reported as 'the record did not yield a document' — emptiness again standing in for a reply that was too long. Raised, and it now says which it was.

A tradesman stood at a doorway a couple of metres inside the building's footprint. Our ray went straight down, hit the roof first, and we faithfully stood him on it eight metres in the air.

So the viewer now uses the one thing it knows that the phone does not: the person was standing on ground a human can stand on. It samples the terrain in rings around the measurement, takes the local ground as the lowest sample, and if the measured point sits well above it — a roof, a canopy, a parked truck — it walks the memory to the nearest sampled point that is actually at ground level.

Bounded on purpose. The search radius is the phone's own reported accuracy, never less than four metres and never more than twelve. It can nudge a photo off a roof onto the pavement it was taken from; it can never invent a position the measurement does not support.

The memory card now says how well the phone knew, in words — GPS STRONG, OK or WEAK — so a memory that looks misplaced can be told apart from one that WAS misplaced.

And any memory can now be corrected by hand, not just the unplaced ones. That was a real gap: a photo that landed in the wrong place had no way to be moved. When the satellites are wrong, the man who was standing there is the authority, and his correction is written down and kept forever.

Past the threshold the record goes two-tier. Every capture still appears and stays citable by its marker, but only the ones this question actually matches carry their full visual read; the rest are listed short — marker, time, the note in the tradesman's own words, the subject. The model is told plainly that a short line is a real capture with a full reading on file, never an empty one, so brevity can never be mistaken for absence.

Measured on the pole card with the threshold forced low: 39,709 tokens of record became 16,818 — 58% smaller — and the same four no-power poles came back with their sources. The ceiling rose with it: a single site can now carry two thousand captures into a question instead of five hundred.

Streaming it exposed the real shape of the wait, which was not what either of us assumed: the model cannot say anything until it has READ, and reading six full-resolution photos is 26,000 tokens of input — about six seconds of silence before the first character. So the first thing down the wire is no longer silence: it is the true scope of the read, printed as READING 66 CAPTURES · 6 PHOTOS at 1.8 seconds, then the answer at 6.1, then the receipts. The machine now shows its work instead of spinning.

Second: a strike now means 'this file cannot be read', never 'the API was busy'. Three strikes drops a capture from the pending pool for good, so counting a 429 or a 529 as a strike could have permanently erased a real photograph from the record after one bad minute. Overload and server faults retry forever; only genuine unreadable files earn a mark.

Third and fourth, the meter and the cache. The corpus is the same bytes for every question about a site, so it is now sent as a cached block with the question left volatile behind it — measured on the pole card: 39,709 tokens read from cache on every follow-up, at a tenth the price of sending them again. And the ask finally returns what it cost (tokens in, out, cached), which retires the Watchtower's standing confession that asks were NOT METERED. That meter immediately earned its keep: it showed the corpus is no longer the expensive part of a question — the six full-resolution evidence photos are, at roughly 30,000 tokens and about nine cents an ask.

The note now goes in WITH the image, and the read is exhaustive: subject, every visible condition and defect, materials and sizes, counts, every readable character, site context — and note_check, an explicit verdict on whether the pixels bear out what the tradesman wrote. On Pole 12 it came back: supports — 'missing ground lug connection confirmed visually; no lug terminal visible at the expected ground bond location.' The record now argues with itself when the photo and the note disagree, which is what an instrument should do.

INDEX_V went to 2, which made every capture pending again, and all 101 across every card were re-read tonight — about thirty cents. The proof is questions that no note could ever answer: 'which photos show corrosion or rust, and on what?' returns rust on the pole enclosures at 6, 8, 9, 10, 11, 12 and 77 with ten sources; 'is there any standing water or debris on this site?' finds it in vaults, ditches and enclosures with nine. Nothing was typed about rust or water. The photographs said it.

And the world now points at itself. Flying a mile-wide site over empty trees told you nothing about where the work was, so the tag pass — which already knows which memories fell outside the frame — tallies them by edge and prints a chip: ▶ 56 on the east rail means fifty-six memories that way. Tapping it flies to the nearest one. It appears only when there is genuinely something off-screen, and gets out of the way the moment a panel or a memory is open.

Also confirmed, since it was asked: the ask bar on the shared map is not a different brain. It reads the same indexed record the cards read — measured on this site it answered '66 captures; 47 include a tradesman note' and returned 66 sources, which is every capture on the card.

Now every capture the model can see is numbered, it must cite the number beside each claim, and it must return the complete list of what it used. Those numbers come back as receipts: the prose reads "no ground lug [1]", and under the answer sits SOURCED FROM 9 CAPTURES — each line a real capture with your note, its time, and a tap that opens its photo, its second of footage, or its 3D. A capture that never had a photo counts exactly as much as one that did; being read is what makes it a source, not being looked at.

Measured on the same question: one lit spot became nine, one thumbnail became nine, and no claim in the answer stands without a number pointing at the capture it came from.

SECOND, THE PROMPT IS AN INSTRUMENT. It now states what a capture line actually is: one photograph and its bonded pair of readings — the NOTE the tradesman typed at the shutter, and the machine INDEX of that same photo. The note is authoritative about identity and condition; the index about what is visibly present; facts never migrate between lines. And the corpus header now declares its own SCOPE, because a one-site ask was answering 'the record contains no scans for any site' — true of its corpus, read by a human as a claim about everything.

THIRD, ONE ASK, NOT TWO. 'I don't want to update one ask button for my cards and then the one for the site map is different.' So there is exactly one implementation now — AskSurface — and the card face, the shared live map, the footage player and home's whole-field ask all mount it. The live map is the only thing this app shares, so it needed the ask most: a link holder proves themselves with the same stateless key the window already uses, and can question THAT ONE SITE with no login and no account. Verified as a guest in a clean browser: opened the texted link, asked 'which poles have no power?', got Poles 12, 11, 77 and 10 with their notes, times, and a proof photo — while the beacons stood on the real ground behind it.

The cause was two frames that disagreed and no way to see it. Our world, and the Esri satellite plane drawn to match it, run X east and Z south. Google's tiles are oriented by their renderer with X facing WEST and Z facing NORTH. That is a half turn about the vertical axis.

A half turn about the site centre is a cruel bug: anything near the centre looks about right, and everything else is thrown to the diametrically opposite side. That is precisely the report — first photo close enough to pass, second one across the building.

The fix does not hardcode the half turn, because then it breaks silently the day the library changes convention. The viewer now MEASURES the frame: it asks the tileset's own ellipsoid where one metre east and one metre north of the site actually land, and uses those two vectors as the basis for every memory, the shelf ring, the live walker, the camera, and the inverse when a finger places something on the ground. Whatever the ground's convention is, the memories follow it.

When there are no tiles, the old placement stands — which is correct, because the Esri plane is what is under you then, and it was never the one that disagreed.

The axis now runs from the first memory to the last at whatever resolution the record actually has — hours within a day, dates across a job — and it labels itself accordingly. On his site it reads 11:38 AM to 4:28 PM, which is the shape of the actual walk.

Scrubbing fills the land in the order the work happened, and the order the numbers are in. Stop at 1:19 PM and twenty-one of the sixty-eight are standing; the roster and its count follow the same cursor, so what you see and what you can list never disagree.

The roster stamps the hour on each row too. "AUG 10" repeated on sixty-eight rows told you nothing; the time of day tells you the sequence of the work.

The card portrait is gone. It captured one rendered frame of Google's tiles and stored it in our bucket as the card's cover art. The Maps Platform terms forbid storing or rehosting map content outside the service, and the caching exception people rely on does not exist for the Tiles API — there is no Map Tiles section in the service-specific terms at all. The old comment in that code even said the quiet part out loud: "zero further Google cost, forever." Three stored frames were deleted from the bucket. Card art is our own imagery again.

The two basemaps no longer share a scene. We were compositing Esri satellite ground underneath Google's 3D tiles, and the terms say plainly not to use Google maps with or near a non-Google map. Esri now stands in only while Google's ground is streaming, or where Google has no coverage, and leaves the moment the real ground arrives.

The credit line names Google Maps and every provider the visible tiles list — it reads "Google Maps · Google; Vexcel Imaging US, Inc." over Bethesda. Naming Google alone is explicitly not proper attribution when other providers supplied the ground, and our old hardcoded line never named Vexcel at all.

The money is fine: about six-tenths of a cent per world opened, with the first thousand a month free. What is not settled is whether billing counts one root request per session or every tile — Google's own two pages word it differently, so the first real invoice decides it.

Two open risks written down rather than guessed at: what an uncovered rural site actually renders, and that our tile key is locked to the web domain — if the Android app ever stops loading from the live site, the map goes dark.

I built a synthetic three-hundred-point day to argue the other side and it changed my mind halfway: where the work is spread out, per-point numbers read like a properly annotated map, far better than counts.

Where it broke was the opposite case — a knot of photos all taken from one standing spot. Laddering them straight up built a tower that ran off the top of the card. Displaced tags now spread sideways as well as up, so a knot becomes a compact block that stays near its ground and inside the window, each with a leader back to its own pin.

Collision testing moved to a spatial grid, because at three hundred tags checking everyone against everyone is ninety thousand comparisons a frame. Each tag only asks its own neighbourhood now.

The timeline is back in the card. I had hidden it to save room, which was the wrong instinct — hiding is never the answer. It rides under the control rail now, where the foot is already spoken for by the stick and the caption.

The world was redrawing sixty times a second forever, even sitting perfectly still over tiles that had finished streaming — a still photograph, repainted, on a phone in someone's hand. Motion, streaming tiles and a live walker keep the full rate; a settled scene drops to about fifteen, looks identical, and stops cooking the battery. The terrain raycasts stop too while nothing moves.

On preloading the ground: the honest version is a preconnect. The first tile otherwise pays for a DNS lookup and a TLS handshake to a host the app has never spoken to, which on LTE is most of the wait before anything appears. Actually pre-downloading the model would be the waste — which tiles you need depends on where the camera ends up, so you would pull megabytes of ground nobody ever looks at.

Now it travels. Its resting right edge sits at 91% of the card; mirrored, its left edge lands at 9% — so the tab slides that exact distance on the turn's own cosine, which puts it precisely on the spine at edge-on, and takes the card's |cos| squash on the way so it foreshortens with the stock instead of gliding across it. Measured through a real flip: right edge 341px → a 9px sliver at the middle → left edge 63px, and it round-trips to 341 exactly on the way back. Written in container units, so if the browser ever can't resolve them the transform is simply dropped and the tab stays where it always was.

Now the focused card answers on itself. Tapping ASK turns THAT card's own face into map + question, in its exact seat in the pile — no scrim, no blur, no second card, the sleeves and the NEW SITE blank still showing behind it. The × returns the same card to its tools. Verified in the signed-in app: card geometry identical before and after, and zero blurred overlays on the page. The ask face is lazy-loaded, so a pile of ten sleeves never pays for it until a card is actually asked.