# BidBrain project status, part 3: Mark's first sessions, v2 (19 to 20 August 2026) Moved unchanged from CLAUDE.md on 2026-09-18. The standing rules stay in CLAUDE.md, which lists every part of this log. - Mark's first live session on his own accounts, 2026-08-19, several fixes: - login.py motorway false positive FIXED. The "logged in" auto detect checked host correct and "login" not in the URL path, but Motorway's own sign in page is at /signin, which does not contain the substring "login", so the check fired the instant the browser landed on the sign in page itself, before any real login happened, capturing a dead session. Fixed by also excluding "signin" from the path check. Caught because a background login.py run (no one at the keyboard) closed itself in seconds; always run login.py with Mark actually present to log in, never unattended. - Cazana cap REMOVED, Mark's decision 2026-08-19 (was: when Cazana is the only valuation and its calculated value is over 10,000, cap the governing value at 9,999, only Glass's could justify going over). Cazana now prices at its full calculated value (retail times 1.15) with no ceiling. pricing.py's Pricing.capped field and the capping block are gone entirely, not just disabled. New python3 daily_run.py --reprice re runs pricing on the cars from the last saved run (no re reading Motorway or Carwow, no re fetching photos, no fresh valuation lookups) for exactly this kind of pricing rule change; _load_cache now drops any stale keys a saved Pricing dict carries so an old cache never breaks a schema change. 106 tests pass. - Carwow test fixture FIXED and made durable. data/inspect/carwow_tab0.html was doing double duty as a live capture (overwritten by every login.py or reader session) and a permanent test fixture, which is exactly what broke it: Mark's own login.py carwow capture landed on the stock page and wiped the old won purchase snapshot the test relied on. Built a small synthetic fixture at data/fixtures/carwow_won_sample.html, shaped to match parse_won's expectations, and pointed test_pricing.py at it instead. Lesson: never point a test at data/inspect, that folder is scratch space anything can overwrite. - Cockpit Make, Model and Year filters ADDED to the control bar (render.py), alongside the existing search box and platform tabs, display only. Model is make specific (choosing a make rebuilds the Model list in JS to only that make's models) and groups by a clean base model rather than the raw derivative text Motorway's CSV bakes into the model field, via a new _model_family(make, model) in render.py: BMW's nnn codes become "1 Series", "3 Series" etc (X models stay as X1, X2...), Mercedes letter plus number becomes "A Class", "C Class" etc (multi letter codes like CLA, GLA stay as is), everything else takes the first word of the model text, with a small named exception list for two word models (Santa Fe, VW up!). Held back cards also carry make, model and year data now so the filters cover them too. - Carwow saved filter URL FIXED, was malformed. bidbrain/browser.py built the Carwow stock_url as a literal "?saved_filter_id=" base string plus, when CARWOW_SAVED_FILTER_ID is set, ANOTHER literal "?saved_filter_id=" plus the id, giving a single param whose value was the nonsense string "?saved_filter_id=" rather than a real saved_filter_id= query. Fixed to append ?saved_filter_id=ID only once. Tested live: the fixed URL and the broken one happened to return the same 39 cars at the moment of testing (both apparently fell back to the same unfiltered or equivalent list), so this was not the reason Carwow showed nothing on the cockpit, but it was still a real bug worth fixing before it silently returns something worse another day. - Carwow "nothing populated" explained, not a bug. All 39 Carwow cars read that day were legitimately excluded: 23 had no Reserve price published yet (Carwow shows only an Autotrader retail valuation, class listing-card-component__retail-valuation-value, on cards still data-listing-state="waiting_for_auction", not the reserve, which appears not to publish until nearer the auction), correctly rejected rather than priced on a guess per golden rule 4 (parse_listing only reads a figure when it finds literal "Reserve price" text, so it never mistakes the Autotrader valuation for the reserve). The other 16 failed real hard gate rules (mostly Land Rover and Jeep, banned makes, plus age and mileage), nothing to fix. Worth knowing: Carwow's next day stock genuinely does not always have a reserve yet when the scheduled run reads it, so some Carwow cars being held or absent on a given day is expected, not a read failure. - Cockpit server not actually live, FIXED. Mark said the page was not live; checked and found no process listening on 8765, no Tailscale installed, no cloudflared binary, and no launchd agents at all on this Mac, so there was never a real public link this session, only assumed continuity with Steven's old Mac Studio setup (a mistake, corrected). Set up com.bidbrain.serve as a launchd agent (~/Library/LaunchAgents/com.bidbrain.serve.plist, KeepAlive plus RunAtLoad, absolute python3.14 interpreter path since launchd does not use the shell PATH, logs to data/logs/serve.log) so serve.py stays up and restarts itself, proven by kill -9 on its process and watching launchd bring it back within seconds. Mark chose to do this step only, not the public tunnel, so the cockpit is reachable at http://127.0.0.1:8765/cockpit.html on his own Mac only for now. - Motorway saved search FIXED, was searching nationwide with no distance limit. The captured stock_url (browser.py) had no maxDistance parameter at all, despite the comment above it claiming "within 210 miles", and also differed from Steven's original brief (missing ageFrom, the grade filter, sellerType=private). This mattered specifically for distance: mileage, reserve, age, grade and owners are all independently re checked in pricing.gate_failures from the real CSV data regardless of the search URL, but distance is the one gate fully trusted to the source filter (Motorway's CSV only gives a location name, not exact miles, assume_distance_ok=True for Motorway in daily_run._assess), so an unfiltered search meant no distance enforcement at all for Motorway cars. Added &maxDistance=210 back to the URL and proved live it is genuinely applied, not a silently ignored parameter: 629 vehicles with no distance param, 499 with maxDistance=210, 2 with maxDistance=5. The other missing filters (ageFrom, grade, sellerType) do not need restoring since pricing.py's gate re checks them anyway, they were only ever a speed optimisation. - THIRD PLATFORM ADDED, Auction4Cars (auction4cars.com), 2026-08-19, alongside Motorway and Carwow. Logged in via login.py auction4cars (a real dealer login, "Hello Steve" on the dashboard is Right Drive's own director, not the original owner Steven, confirmed with Mark before proceeding). Reader is bidbrain/readers/auction4cars.py, built against real captured live pages (list and detail), same shape as Carwow: parse_listing reads the Cars tab list cards (make, model, derivative, year, mileage, transmission, fuel, location, starting price, listing link, from clean .vehicle-card-container markup), paginated by read_all_pages via a page number select dropdown (proven live: selecting page 2 loads a wholly different 18 cars, 31 pages, about 541 vehicles total), and enrich_from_detail visits each list gate candidate's own page for reg, owners, service history (derived from the Service History table, full only when every row is Main Dealer) and free text notes (the More Information paragraphs, SVA boilerplate line excluded). Wired into daily_run.py as _read_auction4cars, merged with mw_cars and cw_cars in both run() and review(). - Three structural gaps against Motorway and Carwow, resolved with Mark before building: (1) NO RESERVE IS EVER DISCLOSED, only Starting Price and a reserve met or not met badge. Mark's decision: Guide Clean (the platform's own lower guide value, read from the detail page) stands in for Reserve everywhere, car.reserve is set from it in enrich_from_detail. Guide Retail is read but not currently used anywhere, flagged to Mark as a possible future signal. (2) NO 1 TO 5 CONDITION GRADE, only a defect map and tyre tread depths. Mark's decision: skip the grade gate for this source entirely, condition is judged by eye from the card. (3) LOCATION IS A DEPOT NAME (for example A4C-Castleford), not a postcode or mile figure. Mark's decision: skip the distance gate too, show the depot name as a location chip instead (car.location, the existing fallback already used when distance_miles is None). All three resolved the same way mechanically: pricing.gate_failures and assess() gained assume_grade_ok (mirroring the existing assume_distance_ok), and daily_run.py's _distance_ok_for(car)/_grade_ok_for(car) helpers decide both per source, used by both _list_gate_ok and _assess so the two never disagree. 122 tests pass, including a new "Auction4Cars reader" section against synthetic fixtures (data/fixtures/auction4cars_list_sample.html, auction4cars_detail_sample.html, never real captured stock, same reasoning as the Carwow fixture). - PRE EXISTING BUG FOUND AND FIXED while making _list_gate_ok source aware: it called gate_failures(car, today) with no assume_distance_ok at all, for every source, not just the new one. Since Motorway cars always have distance_miles=None (Motorway trusts its search filter instead of reading real distance), _list_gate_ok was rejecting every single Motorway car, proven directly against three real cars from a live shortlisted run (all three failed _list_gate_ok despite being genuinely shortlisted). Practical effect: mw_candidates in run() ended up empty, so the whole Motorway detail page pass (keeper start date, known mechanical issue, warning lights, private plate valuation fallback, photo backfill) has been silently not running, and the "fail loudly if the detail read gets almost nothing back" safety net never triggered because it only checks when there are 5 or more candidates. Mark chose to fix this in the same change rather than separately. Fixed by the same _distance_ok_for/_grade_ok_for helpers above, now threaded through _list_gate_ok too. Verified: the same three real cars now pass _list_gate_ok. - Auction4Cars notes on the card, a new generic mechanism, not Auction4Cars specific. Car gained a notes field (free text, flag only, never gates) and assess() appends "Seller notes: ..." to the flags when set. Deliberately not reused as mech_issue or electrical_issue since free text cannot be reliably auto classified into reject versus flag, so it always shows as a flag, never a rejection, letting Mark judge it himself. - Auction4Cars logo captured from images.auction4cars.com/a4c/img/resp-images/2022-a4c-logo.png (assets/a4c_src.png, assets/a4c_logo.datauri), same "used only to label the link to that platform" basis as the Motorway and Carwow logos. Unlike those two, the Auction4Cars badge already carries its own orange background baked into the image, so it sits on a white pill directly, no separate white variant needed for the CTA button. - No saved search or filter mechanism found for Auction4Cars. The page has Make, Model, Year, Location, Price, Mileage, Transmission, Fuel, Body type and Specification filter controls, but they are a custom JS widget, not URL driven (confirmed: selecting a filter did not change the address bar). Left unfiltered, same fallback already accepted for an unconfigured Carwow: the buying rules in pricing.py cull the full list, it is just slower (31 pages, about 541 vehicles, all read and gated before pricing). - Auction4Cars auctions do not sell the next day like Motorway and Carwow, they run 3, 5 or 7 days (Mark 2026-08-19, spotted live). parse_listing(page_html, today=None) now reads each card's data-auction-end-date (epoch ms) and keeps only auctions ending today or tomorrow, everything else is silently skipped, the same way Carwow silently skips a non auction listing state. read_all_pages(page, today=None, max_pages=None) threads today through and stops early once two pages in a row have nothing in the window (the list's own default sort is soonest ending first, proven live), a speed optimisation only, parse_listing's own date filter is what makes it correct regardless of sort order. daily_run._read_auction4cars passes today=date.fromisoformat(sale_date). Fixed the same day it was added: read_live's old "no cars means the page changed" loud failure would have wrongly fired on a genuinely quiet day (nothing ending soon), now checks for at least one readable auction id in the raw page instead of a non empty date filtered result. Verified live: 541 cars unfiltered fell to 298 ending today or tomorrow on a real run, 124 passed the list gate, all correctly enriched and gated. 138 tests pass, including a second synthetic card in the list fixture dated a week out to prove the window filter drops it. - SETTINGS PAGE for the buying rules, BUILT 2026-08-19 (Mark: rather than get a search filter URL from each auction house, most of which turned out not to expose one anyway, edit the rules BidBrain itself enforces). Covers the hard gate (max mileage, max reserve, min and max age, max distance, allowed condition grades, max owners) and the list shaped bans (banned makes, banned models, van and commercial model names, value caps, small city car tokens and their cap limit). Deliberately NOT covered: the pricing formula (FLAT_SPREAD, RETAIL_UPLIFT, GOVERNING_THRESHOLD) stays code only, a bit of friction on the real margin by design, and BANNED_ENGINES plus LITRE_BANS (32 structured rules with token matches, make restrictions and year windows) stay code only too, shown read only on the page for visibility, a naive editor for these risked a malformed rule silently letting a banned engine through. Motorway search URL auto regeneration from these settings was considered and deferred: the current URL's own mileage parameter is deliberately looser than the real 90,000 mile gate (Mark's own buffer), auto generating it would have silently collapsed that. - bidbrain/pricing.py gained DEFAULT_SETTINGS (a dict built from the existing constants, which stay as the factory defaults) and every function that reads a gate threshold or ban list (gate_failures, banned_make, class_exclusion, is_small_city_car, assess) gained settings: dict = None, merging {**DEFAULT_SETTINGS, **(settings or {})}. price_car and banned_engine are untouched, matching the formula and engine rules staying code only. settings=None behaves exactly as before, proven by test. - bidbrain/db.py gained a settings key value table (value stored as JSON so a row can hold a number, a list, or a list of objects) and get_settings()/set_settings(values), following the same connect/close/upsert convention as set_bid. set_settings only touches the keys given, a partial save (for example just Save on the hard gate section) never wipes the list shaped bans. - daily_run.py gained a cached _get_settings() (reads db.get_settings() once per process). _assess() and _list_gate_ok() both read it internally rather than taking it as a parameter, this was a deliberate choice after finding the assume_distance_ok bug earlier the same day, threading a new parameter through many call sites is exactly how that bug happened, an internal cached lookup cannot be forgotten at a call site. - serve.py: GET /api/settings returns {**DEFAULT_SETTINGS, **db.get_settings()} plus banned_engine_names (for the read only section) so the page always shows real effective values even before a first save. POST /api/settings validates before saving (numbers positive, min_age <= max_age, allowed_grades a non empty subset of 1 to 5, list items non empty strings, value_caps rows need a make and a positive cap) via a new _validate_settings(d), raising ValueError on anything wrong, caught by the existing generic exception handler and returned as the usual {"ok": false, "error": ...} shape, no new error plumbing needed. GET /settings.html renders bidbrain.render.render_settings() fresh on every request rather than writing a file, it has no run data dependency unlike cockpit.html so there is no reason for it to go stale. - bidbrain/render.py gained render_settings(), modelled on render_hidden()'s shape: fetch current settings on load, vanilla JS chip list editors for the simple string lists (banned makes, van models, small city car tokens), small table editors for the paired and structured ones (banned models, value caps with an optional model and exceptions), one Save button posting the whole object. A quiet "Settings" link was added to the cockpit's control bar (render_page) so it is reachable from the app, not just by typing the URL. - Verified live end to end: /settings.html shows the real current values, editing max distance from 210 to 250 and saving persisted through a fresh page reload (confirmed both in the browser and by reading the database directly), an invalid save (min age set above max age) was correctly rejected server side and did not touch the stored value, and a get_page_text check that first looked like empty value cap rows turned out to be a tool limitation (it does not read input value attributes), a live JS check against the actual DOM confirmed all six value cap rows were populated correctly throughout. Test values were cleared back to factory defaults (an empty settings table) afterward. 138 tests pass, including settings overrides for every gate and ban function with settings=None proven to match today's behaviour exactly, and a settings table round trip test in a temp database. - COCKPIT LAYOUT: search and filters moved into a left sidebar, 2026-08-19 (Mark, the top control bar had grown cramped: tabs, search, Make/Model/Year, sort, Settings, run buttons all on one wrapping row). The search box and every filter dropdown (Make, Model, Year, plus two new ones, Transmission and Body style) now live in a sticky `