Changelog

The support conversation, message, and request tables were added to the production database with row-level security and owner-only policies, and the migration was written into the migration ledger. Every other migration in the repository was checked against the ledger; none were missing.

When the database is unreachable, the support request endpoint now returns a clean service-unavailable response instead of an unhandled server error, so a request can never look like it succeeded when nothing was saved.

Jake now monitors the TuneView alert inbox three times a day (every 8 hours). When he finds an error alert, he diagnoses the root cause, files a GitHub issue with the fix if it is a system fault, and emails affected customers directly when the issue is on our side. The first alert type he handles is Round 2 upload health, with more to follow.

The upload form was tagging .hpl files with the wrong MIME type in storage. This did not affect analysis (the worker checks the file extension, not the content type), but it is now corrected for storage accuracy.

• A new support assistant is available from the Support button on every page. Ask it questions about getting started, what an analysis costs, which platforms are supported, and what to do with your log file.
• When a question needs a person, the assistant points you to a real human at [email protected] — no waiting on hold, no dead ends.
• It answers questions about TuneView itself. For tuning guidance, the Knowledge Base remains the place to dig into calibrations, fuel, spark, and knock.

• The homepage has been restructured into a clear narrative that answers the questions a first-time visitor actually has: what is TuneView, who is it for, where it works, when you need it, why it exists, and how to use it.
• The hero now opens in plain language instead of jargon. A new problem section frames the pain of conflicting tuning advice before the solution appears. A new section explains what TuneView is, who it's for, and where it works, including supported platforms and a trust badge row.
• A new section explains what a parser is and why it matters, so the parser-vs-AI distinction is something anyone can understand instead of developer jargon.
• The How It Works section now includes the live scan animation showing the parser reading 19 channels in real time, plus a revision loop diagram.
• The pricing section now shows a no-expiration callout, a value comparison, and a safety net panel explaining what happens if your log is corrupted or your platform isn't supported.

• All marketing copy across the homepage, pricing page, FAQ, and about page has been rewritten in plain language. Technical jargon now lives in the FAQ where visitors can go deeper on their own terms.
• The navbar and footer labels have been updated to match the new section names.

The pattern correlation memory that helps TuneView learn from past analyses has been migrated from local storage to the cloud database, so insights accumulate across deployments instead of resetting on every service restart.

Added 25 tests covering scoring utilities, report formatting, API pagination, and component rendering to catch regressions before they ship.

A deterministic post-pass adds confidence shrinkage (per-sample-count, lighter for wideband evidence), same-sign region grouping, isolated-cell demotion, and inverse-distance blend fill. Smoothing shape (edits/monitors/blends/regions per report) is telemetered to vve_smoothing_log, and blend adherence is recorded on every table verification so the blend band can be validated against real tuner pastes. Note: overall VVE error now reflects confidence-shrunk magnitudes, so trend baselines shift slightly downward from this release onward — a reporting change, not a mechanical one.

calibration_knowledge.category held 972 distinct values — two parallel slug taxonomies plus free-text titles. A backup-table + in-place UPDATE migration (ledgered in schema_migrations) mapped all 972 values into 23 canonical buckets. The 'general' bucket tops up sparse retrieval results instead of joining the complaint-driven filter, so broad content cannot crowd out specific categories under alphabetical ordering.

A release check had a stale network bypass that let real failures pass CI silently. It now fails on genuine errors and only skips when the network is truly unreachable.

Coverage pages that described the same hardware under slightly different names are now a single page, so the entry counts read true and there is one place to look instead of several.

Corrected how TuneView pages are listed for search engines, so each page has a single address and pages that were never meant to be public no longer appear.

• The About page now explains why Ryan Lippmann built TuneView around a measured log, revision, and re-log cycle.
• It links the founder's 416 Whipple Sierra revision-loop story and his source-backed construction project-controls case study.
• The page also makes TuneView's evidence-first product contract easier to understand.

• Covers one vehicle or motor.
• Includes unlimited analyses and revision rounds.
• Never expires.
• The website, app, checkout, and Terms now present the same single offer.
• Existing customer access and purchase history remain intact.

We raised the minimum text size and increased supporting-text contrast across TuneView, so labels, chart details, and helpful context stay readable without losing the diagnostic layout.

Jake now runs on a faster, more economical model (Sonnet 4.6) that keeps answers accurate while cutting the cost and latency of every question.

• Analysis modules now bind a log channel only on an exact channel-name match. A name TuneView does not recognize stays unbound and the module reports it as missing rather than reading a similarly named column.
• Torque and airmass export units (lb·ft/Nm, g/mg) are read from the log's own units row, per channel.
• Reports can no longer fail to save on a non-numeric metric value.

Added a short About page with company and founder information.

• A protected read-only production audit now checks the Stripe catalog, webhook configuration, payment ledger, refunds, claims, and entitlements for drift.

• Accounts with no purchase now say "No tune purchased" instead of presenting a Free plan. Grandfathered products and active retired subscriptions remain visible with Legacy labels rather than being mistaken for something TuneView still sells.

The headline now says what you actually get back from a datalog. The free way in reads "add your vehicle" rather than "add your truck" -- TuneView covers Camaro, Corvette, CT5-V and other Gen V platforms, not only Silverado and Sierra.

The homepage now explains that you upload an HP Tuners CSV datalog and receive a tune-health summary, recommended revisions, and a downloadable detailed report in minutes.

Fixed a fault that could stop a completed analysis from being saved on a full-tune purchase. Affected uploads can simply be re-run; nothing was charged twice and no purchase was lost.

Measured across 470 real logs first: 83% carry only the aggregate channel, 14% carry both, and none carry per-cylinder alone. Reports for that 83% are byte-identical to before. Of the 67 logs rich enough to test, 23 flagged an isolated cylinder and the rest stayed quiet.

The first pass searched the source for old prices and plan names, which missed files carrying only a checkout link -- including the homepage and navbar buttons. Caught by re-checking the published page rather than the code, and corrected.

The entitlement, checkout and upload paths were reworked end to end, and the storefront now offers only what can actually be bought. Several defects were caught before release, including report access that would have failed closed for new buyers.

Stricter definitions and application rules were applied. Some existing user records were affected minimally. The majority were founder cases.

The mandatory practice runs that precede any regrade caught four defects before a single stored report was rewritten: a crash on one corrupt archived log, an unbounded file transfer that could stall indefinitely, a dropped database connection at the moment of writing, and — most consequentially — a case where a transient download failure caused a report to be re-decided from stored summary numbers instead of its log. That last one now stops and declares the skip rather than proceeding on thinner evidence. Same-day runs also file their backups and records under distinct names so two runs can never overwrite each other.

The corpus-wide channel audit was re-run to verify every shipped binding fix by measurement, the append-only channel record and its regression tests grew accordingly, and two imprecise claims found along the way were corrected in the record rather than edited away.

Pre-regrade state is retained in full, round-over-round trend history was rebuilt to stay coherent with the new grades, and internal retention records were corrected so every case accurately reports whether its original log file is still on hand.

• The filter deciding whether a knock sample counted as "under load" required throttle above 60% and manifold pressure at 80% of atmospheric or higher. That is a wide-open-throttle test wearing the name "load", and it discarded the entire part-throttle range — including low-RPM, light-pedal, top-gear driving, where a loaded engine sees high cylinder pressure and is most likely to knock.
• Knock now gates on manifold pressure. At half an atmosphere or above, the engine is filling cylinders and making torque, so those samples count toward the verdict. Closed-throttle deceleration, where the manifold sits in vacuum, is still excluded, and a single isolated spike still cannot raise an issue on its own.

• v2.2.11 stopped knock grades from being set by the raw peak retard in a log and started judging retard under load instead. That change was correct and it stands: retard spikes on closed-throttle deceleration are false knock, and they were pulling down grades on healthy tunes.
• The threshold defining "load" is what was set too narrow. Because it effectively meant wide-open throttle, part-throttle driving fell outside it — and one case we published as moving from D to B was a genuine knock finding sitting in the range the filter skipped.
• On that log, 216 of 32,369 samples cleared the old threshold — 0.67% of the file, all from two short wide-open-throttle pulls. Re-run with the corrected gate, 17,518 samples count as loaded, peak knock retard under load goes from 2.1° to 14.95°, and the case returns to D with a critical knock finding.
• Credit for finding it goes to a member on the HP Tuners forum who ran his own log against our report and pushed back when the verdict did not match what he was experiencing in the truck.

Reports generated before today still carry the earlier verdict. We are re-running the archive against the corrected gate and will publish what it changes, the same way we publish every other regrade.

Internal testing of knowledge-base-augmented revision steps. When active, steps show their source (parser vs AI) for quality evaluation.

The Download Report Card button now produces a paginated 8.5x11 PDF instead of one tall PNG image — easier to share, attach, and print. The export still carries the full card view and the technical review in a single document.

• Knock grading now keys off the load-gated knock measurement — timing pulled while the engine is actually under load — instead of the raw peak across all retard events. Decel and transient chatter can no longer cap a grade on its own.
• A single unconfirmed severe sample can raise a warning, but it never sets the grade by itself.

Report pages now lead with the tune grade itself; analysis confidence is shown as a supporting metric. Cases without enough gradeable data show "NEED BETTER DATA" instead of a letter.

As our methodology requires, we regraded all historical cases under the new rule and disclose the result: 2 of 244 graded cases changed — one rose D→B (its raw knock peak was decel chatter, not detonation under load), one moved D-→D. Published trend metrics are parser-measured and unaffected.

Fixed a case-record write that could fail after a successful upload, plus a caching error in the knowledge-base context layer.

Tidied how public pages present themselves to search engines.

Expanded internal monitoring of the analysis pipeline and member experience.

When your case has used all of its included follow-up rounds, the end-of-report panel now links you directly to starting your next case or back to your dashboard — instead of leaving you at a dead end.

Improved the accuracy of internal signup and analysis-pipeline metrics.

Checkout now degrades gracefully if the payment provider rejects an optional session setting, and failed checkout attempts are recorded server-side so a silent checkout failure can never go unnoticed again.

• This fixes a real workflow flaw, not cosmetics: the old completion message told you the upload was done and you could leave the page — right when your report was still being built. People walked away, never saw the finished report land, and re-uploaded the same log thinking it had failed.
• After your log uploads, the waiting screen now shows a live task checklist — secure upload, verification, queueing, retrieving your datalog, parsing & diagnostics, and grading — with the current stage highlighted in real time.
• The analysis worker reports its actual progress while it runs, so the checklist reflects what is really happening, not a guess.
• Clearer wording throughout: stay on the page and the finished report replaces the checklist the moment it is ready — and if your connection does drop, the analysis keeps running and the report still saves to your vehicle.

Improved internal monitoring and recovery procedures for the analysis pipeline.

The 416 Whipple Sierra is pausing logs for a documented front-end structural rebuild. The update shares the driver-side twist survey, the planned frame-horn, suspension, and engine-cage work, and the verification required before the truck returns to the revision loop.

Ford and Mopar coverage is paused while we deepen GM Gen V LT and LS support. Existing Ford and Mopar knowledge is preserved and will return when coverage reopens. The Ford early-access page is offline for now.

Links to tuneview.io/reporting or tuneview.io/trends now forward to the public System Trends report at app.tuneview.io/trends instead of returning a 404.

Secondary and label text across every page is brighter, and the smallest text sizes were raised site-wide — including in the emails we send. Labels, timestamps, and fine print that used to be hard to read against the dark background now meet accessibility contrast standards.

The new Stories case study follows a real 2,142-row review from pending to zero unresolved. It shows exact rows that passed, exact rows that failed, and how parser-owned evidence, required fields, canonical sources, and independent audits keep rich-looking but incomplete guidance out of the public Knowledge Base.

The shop page and several technical guides now describe the same contract: start from log evidence, receive P1-P4 table and cell revisions, then use a comparable follow-up log to judge the result. Older public pages that did not support that path have been removed.

Measured Results now states the contract plainly: TuneView's in-house parser applies the same fixed thresholds to every matched round, and a general-purpose AI model does not decide whether a result improved, held, or got worse.

A new homepage section explains where AI can help organize and explain parser-owned evidence, and where it has no authority. AI does not grade logs, set HP Tuners values, change thresholds, invent platform behavior, or replace next-log verification.

The public results page now leads with round-over-round verdicts and clearly separates customer-fleet results from the founder development vehicle. Both scopes keep their own sample counts, suppressed months, and underlying methodology so the data can be judged on its own terms.

The founder's 2015 Sierra 1500 went through two real analysis rounds: one airflow-model recommendation improved, two held flat, and two startup-idle recommendations got worse. The story shows the logged regions, recommended corrections, and measured verdicts without hiding the misses.

Removed the granular per-step pass/fail scoring tool from individual reports — it asked for a judgment call on raw metric deltas that most of the time only made sense with tuning-specific context. The plain revision-step checklist stays, and the public, aggregate System Trends report remains the source of truth for round-over-round improvement.

• It took us a minute, but now you can upload your VVE and MAF tables to further enhance datalog interpretation and tune step accuracy.
• Here's why this is the biggest change we've shipped: a datalog shows the symptoms, but your tables ARE the calibration producing them. Until now, TuneView was diagnosing your tune from the outside. With your actual VVE grid and MAF curve in hand, analysis can line findings up against the exact cells in your editor — the same numbers you're about to change.
• How it works: in VCM Editor, right-click your VVE virtual table or MAF calibration and choose Copy with Axis, then paste it into the new Tune Table Paste box on your vehicle's follow-up upload page. TuneView parses it on the spot and echoes back what it read (grid size, RPM range, MAP axis in bar or kPa) so you can confirm it matches your editor before it's attached to your case.
• Bad pastes are caught immediately with a plain-English reason — plain Copy without the axis, a truncated grid, a non-numeric cell — so nothing silently wrong ever enters your case.
• A lot of the smaller updates over the past weeks — channel mapping, grading only what a log can prove, the boost-detection ruling — were quietly laying the groundwork for this. This is the foundation for what comes next: revision steps computed against your actual table cells, not descriptions of regions.

A new public reference at tuneview.io/log-channels lists every VCM Scanner channel TuneView looks for — what's required, what unlocks a complete grade, and what sharpens verdicts — plus step-by-step Copy with Axis instructions for both VVE and MAF tables.

Deduplicated case records with a uniqueness guarantee, normalized report storage for faster queries, and rebuilt round-over-round trend history so deltas stay coherent across the regrade. Full audit trail in the migration ledger.

• Months withheld for sample size (n < 10) previously rendered as blank gaps in the trend charts, which made sparse series look broken.
• Each chart now shows hollow baseline markers for exactly which months each series was suppressed, and hovering a withheld month shows its sample count.
• Per-chart footnotes explain what you're seeing — including why the boost wideband chart has no customer months yet and that the founder series is a single development truck under active tuning.

General infrastructure upgrades. No customer-facing changes.

• Your letter grade is now computed only across the systems your log actually contains enough data to evaluate — a short log no longer drags your grade down for systems it couldn't see.
• Case reports show exactly which systems were graded ("Graded on 9 of 12 systems") and what to log next time to unlock the rest of your grade.
• If fewer than 6 systems are evaluable, you get an honest "Incomplete — Need Better Data" instead of a misleading letter.

• Tiny knock-retard readings below the platform's noise floor no longer count against you — single sub-degree blips are sensor noise, not detonation.
• Real knock is treated more seriously, not less: sustained retard at critical levels now caps the overall grade at D no matter how clean the rest of the log is.
• Grades move in both directions under the new formula — some go up, some go down. That's the point.

The full grade formula — which systems count, how issue severity is weighted, the safety cap, the knock noise floor, and the letter scale — is now published on the System Trends page. Deterministic and versioned: same log, same grade, and the version is stamped on every report.

The public accountability report now lives at app.tuneview.io/trends. Old links redirect permanently.

All historical cases were re-scored under the new formula so your case history, vehicle trends, and the public System Trends report all reflect the same standard. A pre-regrade backup was taken first.

• Revision steps now use the correct HP Tuners VCM Editor paths: Edit → Virtual Volumetric Efficiency and Edit → Virtual Torque on GM, Edit → MAF Transfer Function on Ford, and Edit → VE Table on Mopar.
• GM VVE steps now walk you through the VE Mode drop-down first (VVT vs non-VVT), so edits land on the coefficients your ECM actually uses.
• GM Virtual Torque steps now prompt you to pick the Table Grouping that matches your vehicle's setup before editing.

• Multiple edits to the same VVE or Virtual Torque table are now grouped into a single step — the way you'd actually make them in the editor.
• Each grouped step renders a mini table grid showing the delta to apply to each cell and, where known, the resulting new value — work from whichever form you prefer.

Internal tooling improvements supporting analysis quality and report maintenance.

A full audit of every analysis module against real logged data tightened status normalization, sensor-value parsing, and channel alignment across the report pipeline.

The live scan demo and Technical Drive Review preview on tuneview.io now label every system with the exact module names your real report uses — startup idle, knock safety, MAF table, data quality, and the rest. What you see on the marketing site is what you get in the app.

The public Accountability Report now has its own REPORT link in the tuneview.io navigation bar — the same spot it occupies in the app — so you can reach the live numbers from any page without scrolling the homepage.

Monthly report snapshots are stored in a database table where frozen rows are immutable at the database level — even we can't edit a closed month without it being a new, visible migration.

Knock & Spark Safety report cards now include an interactive chart of your actual logged data: RPM, throttle, knock retard, and timing plotted over the log, so you can see exactly where the ECU pulled timing instead of taking the verdict on faith. More modules to follow.

Founder account data-import and tooling housekeeping. No customer-facing changes.

Housekeeping so the TuneView team can evaluate features end-to-end on the live site. No customer-facing changes.

• Step cards now carry one line each — full detail moved into the click-to-expand view ([+] MORE).
• New parser-first strip: a deterministic in-house parser reads every log before any AI touches it (format gate, channel map, pull detection, fail-closed).
• The re-tune loop is now a connected four-node flow — baseline report → apply the edits → re-log & upload → change report — looping back to the next revision.
• Corrected marketing copy: removed the free-first-upload claim and reworded the pricing headline to "Start with a single case."

On locked reports, opening a module's detail view now shows a preview of the step-by-step tune revisions — clearly-marked sample steps, grayed out and fading to black, with an unlock button centered over the preview leading to the full HP Tuners revision instructions.

Each scan now records the signed median wideband-vs-commanded error across all in-boost power-enrichment samples. Rounds analyzed before this change read indeterminate on boost steps rather than being mis-scored against fuel trims.

The paywall redaction now strips tuning instructions at the source: revision steps, per-module recommendations, technical drive review, calibration correction cells, and KB research data are all removed server-side before a locked report leaves the API.

Beta labels and notices are gone across the app and site. "Beta Terms of Service" is now simply the Terms of Service, with app.tuneview.io/terms pointing at the single canonical terms page.

The homepage now says what the re-log loop actually gives you: exact revision steps, then a verdict on your next log — what improved, what regressed, and what to do next. Less abstract, closer to how the product behaves.

A practical guide to reading KR in your logs — what the channel actually measures, how to separate real knock from false knock, and when a KR event is worth a tune change.

How to tell whether your fueling error lives in the MAF curve or the VE table before you start editing either one, using the trims and conditions already in your log.

The Terms are updated for paid access. They spell out that TuneView provides analysis and guidance only, that you assume the risk of applying any suggested revision or editing guidance to your vehicle, that you're expected to have the required diagnostic equipment and mechanical knowledge, and that emissions-control tampering is prohibited use.

Terms, Privacy, the LambdaWorx privacy policy, and Trust & Security now live behind a single Legal page, each with its own version and effective date. The navbar and footer link to LEGAL instead of four scattered entries.

Checkout now asks for one acknowledgment: a single checkbox confirming the Terms of Service and Privacy Policy before you purchase. No other sign-up or per-feature legal prompts were added.

The web-to-app redirect policy is documented so future public-site reviews can tell which paths should redirect, which stay on tuneview.io, and why direct /ford links are public while homepage placement can be controlled separately.

The /ford coverage page no longer depends on the homepage Ford-section feature flag, and robots.txt no longer blocks the route.

All three assign surfaces call a single shared helper that PATCHes each case and reports per-log success and failure, so partial failures surface instead of silently dropping logs.

The anonymous upload flow, vehicle round-2 uploads, and the saved case detail page all render one shared report card component driven by the stored analysis snapshot — three duplicated render paths were deleted.

• Vehicles created during intake defaulted to the engine platform you picked — not much of a name for your build. Every vehicle page now has a Rename control next to the title, so "L86 — 6.2L Gen 5 Truck" can finally become "Red Sierra".

• Logs analyzed before you saved a vehicle — or uploaded outside a vehicle page — used to sit unattached in your case list. Each unassigned log on the dashboard now has an "Assign to vehicle" selector that files it under any vehicle in your garage.
• Assignment is one-way for now: once a log belongs to a vehicle it stays there, so round tracking and trend history stay honest.

• Some HP Tuners exports name the time column "Offset", and part of the analyzer missed it — reports could claim required channels were missing and ask you to re-log data that was already in your file. Channel identity now comes from the log parser's own mapping everywhere, so what the parser found is what every module sees.
• Log Quality scores no longer take a false hit on affected logs.

• Recommended revisions are now always generated from the parsed log data first. The AI pass runs last and only adds steps that bring something new — an uncovered system or a knowledge-base citation — and can no longer ask you to capture channels your log already contains.

• Every report card now leads with a dedicated Recommended Tune Revisions section — priority-sorted steps with the system, target table, and what to change in your editor. No more digging through individual module tiles to find them.
• The same panel appears on saved case reports, so the steps are always one click away when you're at the bench with VCM Editor open.

• Uploading a log while signed in now always files it under a vehicle. Pick one of your saved vehicles — or do nothing and TuneView saves a new one from your build profile.
• That means every follow-up upload for the same vehicle automatically gets round-over-round treatment: measured verdicts on last round's steps plus fresh recommendations, with no extra setup.

Follow-up uploads can now include your current calibration file (.hpt/.efi) and a dyno sheet (PDF or image) alongside the log. They're stored with the round for tuner review.

Follow-up uploads now record log-trend metrics the same way first-time analyses do, so round 3 and beyond build on a full metric history for the vehicle.

• A new homepage section shows what account holders get with every analyzed log: the long-form Technical Drive Review — a printable engineering white paper covering every channel, module finding, and revision action behind the report card.
• Includes a document preview and direct links to start free or sign in and view yours.

The /cases list, detail, and dashboard endpoints now decode string-encoded stored reports (same root cause as the v1.0.3 Round 2 fix, on a different read path), with a safe empty-report fallback for malformed data.

The backend now decodes stored case reports defensively when carrying the prior round's steps forward; malformed or legacy-encoded reports no longer break follow-up uploads for vehicles with existing history.

If you upload an unmodified OEM stock calibration file, we now spell out exactly what happens to it: VIN, owner name/contact, and dealer code are stripped before anything is added to TuneView's knowledge base, and the anonymized result only powers aggregate stock-vs-tuned comparison features. Your original file still follows the retention schedule in the Privacy Policy.

SPEC-4 Phase 2 SQL applied: 3,000+ GM Gen V / EcoTec3 rows normalized to the Gen5_All retrieval sentinel, 370+ LS/Gen III-IV rows normalized to a new LS_All sentinel (RPC special-cased), multiple sentinel added to the RPC list, and 10 Electric rows corrected. The engine_families count drops from 616 to 281 — expected consolidation, not a regression.

The hardcoded first-paint stats in lib/kbStats.ts updated to 15,523 entries / 843 categories / 281 engine families (2026-07-03), reflecting the post-Phase-2 baseline. The live /api/stats fetch still overwrites these on hydration.

• TuneView was always supposed to be a loop, not a one-shot report: tell us your goal, we walk you through specific edits, you re-log after making them, we check whether it worked before telling you what's next. That last step was missing until now.
• After you upload a Round 2 or Round 3 log, you'll see a new section asking how last round's changes actually went: improved, no change, worse, or not applied. That answer feeds directly into the system generating your next set of steps, not into a form that goes nowhere.
• This only shows up for steps tied to a specific recommendation, not the generic "capture more data" placeholders you sometimes see early on.

Recommendations are now generated using TuneView's full calibration knowledge base and outcomes already confirmed by other tuners on similar issues, instead of falling back to simplified logic. This runs automatically on every round — nothing you need to do differently.

We found and fixed an issue that could cause a log upload to fail with an error. If an upload didn't go through for you recently, that's resolved now — give it another try.

A stamp-style badge now sits at the top of the homepage announcing extended beta access, with free tune analysis for both new and existing accounts.

Removed the email capture field and its secondary "Get Early Access" button from the hero — Start Here is now the single, clear call to action.

The Start Here button on the homepage now takes you straight into intake instead of hitting a missing page.

Trimmed decorative slashes from section labels across the site and removed an unused stats ticker for a calmer, more readable layout.

The live CASE_001 scan card — overall grade, per-system modules, and the P1 fix — now sits directly under the hero, so you see what a TuneView report looks like before the explainer sections.

The transmission module in the sample scan reads as a real finding instead of a raw NaN flag, and the contact card now points to the community Discord instead of a placeholder phone line.

Changelog, legal, privacy, KB, and family pages now carry page-specific canonical/social metadata. Public stats reads also keep both moderation_status=active and deleted_at IS NULL filters, and CI now checks that the first-paint KB fallback never exceeds live stats.

The homepage now keeps one active-beta note in the hero and removes outage-flavored copy from the Early Access area, so the pricing path is not surrounded by reliability warnings.

While the Ford section remains feature-flagged off, robots.txt now disallows /ford so the gated route is not crawled or indexed. When NEXT_PUBLIC_FORD_SECTION_VISIBLE flips on, the disallow drops automatically.

The signed-in billing cards now render canonical plan features instead of only the short description, reducing drift between the public pricing page and the final purchase surface.

The app billing route now renders the requested plan from the same canonical billing plan map used after sign-in, keeping the public CTA, account gate, and checkout path aligned.

Stripe success URLs now include the Checkout Session ID placeholder, giving TuneView a concrete reconciliation handle on the post-payment return path.

After Stripe sends a customer back to TuneView, the billing page now says payment was received and checks for the plan update instead of immediately claiming activation before the webhook finishes.

The dashboard now loads the user's billing fields from the account API alongside case history, so plan messaging follows the same entitlement state used by billing and intake gates.

The app now owns a dedicated /start route for new-user intake entry, redirects legacy /auth?next=... traffic into the dashboard auth wall, and preserves next=/portal/intake after sign-up.

The public /intake route now redirects to the app intake route, public navigation/error/portal CTAs point to the app-owned intake surface, and the old website intake form components were removed from the active tree.

The Round 2 upload endpoint now counts prior follow-up parser scans for the vehicle and blocks uploads after the two included re-evaluations, returning the current round and remaining upload count to the app UI.

Profile counts now cross-check case ownership against vehicle rows, vehicle deletion refreshes the full account summary, and billing portal errors preserve backend detail for the UI.

The app now uses a shared score selector that reads report_header_rollup.computed_score first and only falls back to legacy client-side scoring when older cases do not have a report rollup.

The canonical vehicle Round 2 upload endpoint now catches unexpected storage, parser, and database failures and returns a structured API response the app can display.

Report assembly no longer emits vague legacy investigate actions. Fallbacks now choose collect_better_log when coverage is weak and reserve calibration_change for concrete module instructions.

The canonical Round 2 parser path now emits manufacturer-safe HP Tuners table guidance for GM, Ford, Mopar, import/euro, and unknown-platform fallbacks while keeping edits tied to logged RPM/load, pedal, speed, and slip regions.

Case and upload report views now carry the generated target_table field through the UI so users can see the exact table or coverage plan associated with each revision step.

When the same intake email signs in for follow-up logs, the database API can attach the anonymous intake vehicle to that account and continue through the canonical Round 2 parser path.

Signed-in and anonymous case views now read the report_header_rollup and provenance_summary fields produced by the backend report pipeline.

Stats, ticker, app Explorer, backend KB stats, and parser-backed table analysis now point at the canonical calibration knowledge base. Legacy row-import routes and migrations were removed from the active tree.

HPT table-upload parsing now delegates through the canonical parser module so tune/log parsing has one owner.

app.tuneview.io/changelog redirects to www.tuneview.io/changelog, and the app nav points directly to the canonical public changelog.

The app KB table shows operational tuning knowledge fields without rendering source/provenance columns in the visible interface.

Website routes for login, dashboard, portal, vehicles, cases, and KB now redirect to the app instance instead of keeping parallel product pages alive on tuneview.io.

Hero support badges and the How It Works support chip now reflect Ford and Mopar as live tuning-support surfaces.

• IntakeForm.tsx: mopar_gen3_hemi added to Platform union, MoparVariant type added, hemi_displacement field wired through FormState → platform_data payload.
• thresholds.ts ENGINE_FAMILY_MAP: mopar_gen3_hemi → gen3_hemi mapping added.
• SQL migration: hemi_displacement column added to intake_submissions + mopar_gen3_hemi added to platform check constraint.

The homepage now renders the standard TuneView sections again instead of the noindex maintenance screen.

The marketing intake form now posts baseline CSV attachments with the `datalogs_0` field instead of the calibration-file field.

Subscribe and unsubscribe now use global Resend Contacts calls instead of requiring a deprecated `RESEND_AUDIENCE_ID` value.

Login, portal, case, and vehicle routes now send noindex metadata in addition to robots.txt blocks, and the retired waitlist API route was removed from the active route tree.

A production QC pass caught mobile horizontal overflow on the maintenance landing page. The headline now wraps more safely and the fixed feedback control has tighter small-screen spacing.

The site no longer patches assessment wording in its proxy route because the database API now returns normalized Round 1 report copy.

The /cases route now avoids calling the database assessment endpoint without a report access token when no matching case row is visible.

The site forwards a per-submission report access token to the database review engine when polling the initial assessment.

• /for-shops COVERAGE: Mopar Gen III Hemi live: false → live: true, variants expanded to include Hellcat/Redeye 6.2SC.
• Pentastar V6, EcoDiesel 3.0, and Cummins 6.7 rows added as COMING SOON — intake form support tracked in LAM-1065.
• 6,174+ KB entries across 392 categories and 221 engine families already cover Mopar platforms end-to-end.

• Email1: unsubscribe URL already fixed in v0.10.5.
• Email2: /upload → /intake (button CTA).
• Email3: /reports → /portal (View Your Report button).

The unsubscribe link in the welcome email pointed to the UI page instead of the processing endpoint, so clicking it showed an error instead of completing the unsubscribe. Fixed to route through /api/unsubscribe.

The scan report page now shows a '← Portal' link so you can return to your vehicle dashboard in one click instead of navigating via the homepage.

The hardcoded first-paint stats for the knowledge base ticker were updated to 4,176 entries / 165 categories / 191 engine families (2026-05-22), reducing the flash of stale numbers before live data loads.

The assessment ready state on the case page was rendering a Grade D badge in amber instead of red, inconsistent with the portal and submitted page. Fixed.

The case dashboard and case detail pages were showing full 36-character UUID codes (e.g. "a1b2c3d4-e5f6-..."). They now show a concise 8-character code (e.g. "A1B2C3D4") that's easier to reference and share.

The "Back" and "Cancel" links on the Round 2 upload page now go directly to your case instead of routing through an extra redirect.

The review step at the bottom of the intake form was showing raw internal codes (e.g. "gm_lsx_ltx", "pump_only") instead of the labels you selected. Fixed — it now shows "GM LSx / LTx (incl. LSA / LT4)", "Pump gas only", etc.

• Ford Coyote, Raptor 3.5 EcoBoost, GT350/GT500 (Voodoo/Predator), and Godzilla 7.3 families added to ENGINE_FAMILY_MAP.
• KB seeded with 50+ Ford rows via Ford Tuning Specialist agent. Round-trip assessment verified end-to-end.
• How It Works coverage chip updated: Gen 5 LT · LS · 6L80E → GM Gen 5 LT/LS · Ford Coyote 5.0 · Ford Raptor 3.5.

• WelcomeEmail footer link pointed to /unsubscribe (UI page) instead of /api/unsubscribe (processing route). Clicking in email never processed the opt-out.
• Added RFC 8058 POST handler to /api/unsubscribe for one-click unsubscribe compliance (Gmail, Apple Mail use this).
• Refactored shared processUnsubscribe() to eliminate duplicate logic.

Added metadataBase to root layout so Open Graph and canonical URLs resolve correctly across all pages. Uses NEXT_PUBLIC_SITE_URL with www.tuneview.io fallback.

The EarlyAccess email capture section had the same 5xx masking gap as EmailCapture — fixed to show a generic user message for all server errors.

• WelcomeEmail CTA button: tuneview.io/signup → tuneview.io/intake.
• Two blog post CTAs in lt1-knock-pattern and ltft-fuel-trim posts updated to match.
• /signup route does not exist — /intake is the correct new-user entry point.

Internal server errors from the subscribe API no longer surface raw error messages to users. Generic user-friendly message shown for all 5xx responses.

• next.config.ts: constrained /blog/:slug redirect to slug([^.]+) so file-extension paths are not redirected.
• Copied hero SVGs from public/blog/ to public/stories/ to cover CDN-cached 308 redirects.
• Updated all four blog post frontmatter hero paths to /stories/hero-*.svg (canonical route).
• Wired missing hero images for lt1-knock-pattern and ltft-fuel-trim posts.

Extracted getSupabaseClient() singleton into lib/supabase.ts. Updated login, portal, and vehicle-upload pages to share a single GoTrueClient instance, eliminating the browser warning about multiple concurrent instances.

• Added gradeFromConfidence() helper mapping overall_confidence to A/B/C/D letter + color palette matching UX Designer portal-dashboard.html mockup.
• Replaced raw CONF % badge with 48px circular grade ring. Stats row renders only when cases.length > 0.

• Added useEffect watching forced_induction in IntakeForm.tsx. When value changes to 'blower', blowerPulleyRef.current.scrollIntoView({ behavior: 'smooth', block: 'center' }) fires.
• A 1.2-second CSS ring flash (box-shadow transition-shadow duration-500) provides visual confirmation. State auto-clears via setTimeout to avoid stale highlight on re-render.

• The /terms page has been rewritten from a thin 9-section placeholder to a comprehensive 14-section Terms of Service covering automotive tuning liability, emissions compliance, tune IP ownership, dyno testing assumptions, refund policy, and indemnification.
• Key additions: California Civil Code §1542 waiver, $100 liability cap, assumption-of-risk acknowledgment, and a Legal Notices section with mailing address.
• Contact section now includes [email protected] and [email protected]. Privacy Policy link added.

• /cases/{id} was calling PendingState with message='Your assessment is ready' while PendingState unconditionally rendered kicker 'ASSESSMENT IN PROGRESS' — three contradictory signals at once (LAM-889).
• Root cause: when vehicle_id=null on the backend, no Supabase cases row is written, so /cases/{id} found nothing and entered a 10-second auto-refresh loop that could never resolve (LAM-952).
• Fix: new AssessmentReadyState component — consistent copy (ASSESSMENT COMPLETE), no auto-refresh, shows grade + summary from the backend assessment, and links to /portal/intake/submitted where the full report card is always available.
• Backend must still ensure vehicle_id is populated and the cases row is created — tracked under LAM-952.

• ForShopsClient was still posting to /api/waitlist (old Supabase-only route). Shop signups were not reaching the Resend audience or triggering the welcome email.
• Migrated to /api/subscribe with source=for_shops_page, matching the Hero and EarlyAccess capture points fixed in v0.9.0.
• 409 (already subscribed) now shows success state. sessionStorage deduplication prevents the form from re-opening on the same session. Progressive-enhancement fallback (action/method attributes) matches the other forms.

• text-t3 (#3A5068) on #060810 background is 2.7:1 contrast — fails WCAG AA.
• Fixed on: ForShopsClient hero kicker, HowItWorks step captions (card + modal), blog/[slug] author/date metadata, blog post email-capture pitch.
• text-t3 retained for intentionally de-emphasized UI chrome (step labels, fine print, placeholders).

• Step cards were click-only divs with no keyboard path. Added role=button, tabIndex=0, onKeyDown (Enter/Space), and focus-visible outline.
• Modal overlay: role=dialog, aria-modal, aria-label. Close button: aria-label=Close + focus-visible ring.

Vehicle Hub makes Supabase + backend API calls server-side with no fallback. Added cases/[id]/loading.tsx skeleton that renders immediately while data resolves.

• All form field labels upgraded from text-t3 (2.7:1 contrast, fails WCAG AA) to text-t2 (~9:1).
• File drop zone made keyboard-accessible: role=button, tabIndex=0, Enter/Space triggers file picker, focus-visible ring.
• Instructional copy in file, compliance, and privacy sections upgraded to text-t2.

• app/error.tsx: catches unexpected server/client errors in any route, shows TuneView-styled error with retry button and nav links.
• app/cases/[id]/error.tsx: Vehicle Hub-specific error with backend-unavailability context and in-place retry via unstable_retry.
• Previously all errors fell through to Next.js's default unbranded error page.

• trust/page.tsx: code annotation (codeNote) and Questions? paragraph: text-t3 → text-t2.
• stories/[slug]/page.tsx: author/date/readTime meta row: text-t3 → text-t2.
• login/page.tsx: CHECKING SESSION / LOADING fallbacks and Email label: text-t3 → text-t2.
• vehicle/[id]/upload/page.tsx: AUTHENTICATING, file field labels, hints, Additional Notes label: text-t3 → text-t2.
• IntakeForm: file hint text, platform-other coverage note: text-t3 → text-t2.
• EarlyAccess: no-spam reassurance copy, Pricing tier name kicker, Proof demo vehicle subtitle: text-t3 → text-t2.
• BlogEmpty + BlogNotFound empty/not-found state messages: text-t3 → text-t2.
• Intentional t3 retained: code comment kickers (// SIGN IN etc), logo splits, scroll indicator, placeholders, hover-only nav links, UI demo metadata labels.

• privacy/page.tsx + privacy/lambdaworx/page.tsx: version metadata and policy redirect box: text-t3 → text-t2.
• terms/page.tsx: version metadata: text-t3 → text-t2.
• cases/[id]/page.tsx: engineFamily subtitle (e.g. 'L86 6.2L GEN IV'): text-t3 → text-t2.
• PostCard: date and author/readTime rows in both featured and grid variants: text-t3 → text-t2.
• Footer nav links (Trust, Privacy, Terms, Changelog, For Shops): text-t3 → text-t2. These are legal/navigation links that must be readable.
• Navbar desktop nav links: text-t3 → text-t2. Same fix as footer — navigation links that need to be read.
• cases/[id] back links (StateShell + report footer): text-t3 → text-t2.
• unsubscribe/page.tsx back link: text-t3 → text-t2.

• autocomplete='name/email/tel/organization' added to Name, Email, Phone, and Shop fields — mobile autofill now works.
• autocomplete='email' added to EarlyAccess, EmailCapture, and For Shops email capture inputs.
• autocomplete='off' on VIN field — browsers won't suggest stale VINs.
• htmlFor+id pairs added to Name, Email, Phone, Shop, and VIN — clicking a label now focuses the right input; screen readers explicitly associate labels to inputs.

app/not-found.tsx now exports robots: { index: false } — 404 pages won't appear in Google results.

• Vehicle Hub report (cases/[id]): CONFIDENCE, SAFETY, PRIMARY ISSUE, WOT PULL, module names, CONF%, step system names, card type labels, NEXT STEP — all text-t3 → text-t2. These are the core data labels in a paid report.
• BlogEmpty + BlogNotFound: empty-state kickers (// 404, // NOTHING HERE YET) — text-t3 → text-t2.
• HowItWorks: [ESC] close button text — text-t3 → text-t2. Close actions must be visible without hover.
• IntakeForm: remove-file button (×), review summary section headers, field name labels — text-t3 → text-t2.
• KBCounter: stat sub-labels (+N this month, category examples, engine family examples) — text-t3 → text-t2.
• ScanDemo: OVERALL SCORE label — text-t3 → text-t2.
• Pricing: price unit labels (/case, /mo) — text-t3 → text-t2. Users need to read the billing model.
• Footer: LambdaWorx attribution lines — text-t3 → text-t2.
• error.tsx + cases/error.tsx: Error ref digest shown to user — text-t3 → text-t2.
• trust/page.tsx: LambdaWorx attribution line — text-t3 → text-t2.
• vehicle/upload: Cancel link — text-t3 → text-t2.

• Added Escape key handler to close the mobile nav drawer (useEffect on document keydown).
• Hamburger button: added focus-visible:outline ring, aria-expanded, and dynamic aria-label (Open/Close menu).
• Nav element: aria-label=Main navigation added so landmark navigation is properly labelled.

• layout.tsx: skip-to-content link added (sr-only, reveals on Tab, jumps to #main-content past Navbar).
• HowItWorks modal: focus now moves to the [ESC] close button when modal opens — keyboard users don't need to Tab through the full modal to find a dismiss action.
• ShareRow, LoadMoreButton, TagBadge, EmailCapture, EarlyAccess, IntakeForm, login, vehicle upload: focus-visible:outline rings on all buttons that were missing them.

• KbTicker: aria-hidden=true — the scrolling knowledge-base banner is decorative (repeated 16×) and was being read in full by screen readers.
• EmailCapture + EarlyAccess: role=status on success message, role=alert on error message.
• Login magic-link sent panel: role=status + aria-live=polite so screen readers announce 'Check your email' after submit.
• IntakeForm submission error: role=alert so screen readers interrupt to announce validation failures.
• portal/intake/submitted: ErrorState div now has role=alert so screen readers announce polling failures. ProcessingScreen section gets aria-label=Assessment processing for orientation.
• for-shops/ForShopsClient: role=status on success, role=alert on error.

• sitemap.ts was missing /intake (main conversion page), /stories, and /terms — all added.
• Post entries now emit both /stories/:slug (priority 0.7) and /blog/:slug (priority 0.6) so both routes are indexed. Each page has its own canonical URL.
• not-found.tsx: BLOG navigation link updated to /stories to match the Navbar.

• Final focus-visible pass: IntakeForm remove-file button (×), app/error.tsx retry button, and cases/[id]/error.tsx retry button were missing keyboard focus rings. All three now have focus-visible:outline-cyan/60.
• Every <button> in the codebase now has an explicit focus-visible ring — keyboard navigation is complete across all interactive elements.
• StoriesList: filtering by tag with no matching posts now shows a '// NO RESULTS' empty state instead of silently rendering a blank area below the tag filter.

• IntakeForm: all 8 form sections now carry aria-label (Contact information, Vehicle information, Hardware modifications, Platform-specific details, Tuning goals, File attachments, Compliance and intended use, Review and submit) — screen reader users can navigate the long form by named regions.
• FileDropZone: replaced blocking browser alert() dialogs with inline role=alert error messages that appear in context and auto-dismiss after 4 seconds. Wrong file type and limit-exceeded errors are now announced without freezing the page.
• TagFilter: added role=group + aria-label='Filter by tag' to the filter button group — screen readers announce the group purpose when navigating into it.

• Every input, select, and textarea in the intake form now has an explicit htmlFor/id pair — 30+ fields total across Vehicle Info, Hardware, Platform-specific, Goals, and Compliance sections.
• Clicking any label now reliably focuses the correct field in all browsers. Screen readers announce the correct field label when the input receives focus.
• Signature field: added autoComplete=name so mobile keyboard can pre-fill from contact suggestions.
• Vehicle year/make/model/trim: autoComplete=off prevents browsers suggesting stale vehicle data from previous form fills.

• TagBadge: interactive tag filter buttons now carry aria-pressed — screen readers announce whether a tag is active or inactive.
• ShareRow copy button: added aria-label that changes from 'Copy link to clipboard' to 'Link copied' after the copy action — previously the icon-only button was unlabeled on mobile.
• Navbar: desktop and mobile nav links now carry aria-current=page on the active route — screen readers can identify the current page in the navigation landmark.
• IntakeForm vehicle fields: Year, Make, Model, and Trim now have htmlFor/id pairs and autocomplete=off — clicking a label focuses the field; browsers won't suggest stale vehicle data.

• All 11 <select> elements in IntakeForm (Platform, Cal file, Forced induction, E85 pump, FFS wiring, Headers, Cats, Fuel strategy, Power priority, Trans, Intended use) now have explicit htmlFor/id pairs.
• Clicking a label now focuses the corresponding select in all browsers. Screen readers announce the correct label when each select receives focus.
• HowItWorks modal: focus now returns to the step card that opened the modal when the modal closes (Escape or overlay click). Keyboard users don't lose their place in the page.
• All text inputs, selects, and textareas in IntakeForm, login, EmailCapture, EarlyAccess, ForShops, and vehicle upload now show a focus-visible:ring on keyboard Tab — previously outline:none removed the ring for keyboard users as well as mouse users.
• login/page.tsx + vehicle/upload: error paragraphs now have role=alert so screen readers interrupt to announce auth and upload failures.

Full intake-to-assessment flow verified with a synthetic 2012 CTS-V build (LSA 6.2L, E67 ECM, DW 90lb injectors, Lingenfelter pulley+intake). All 10 defects from the prior dry run confirmed fixed.

• The assessment generator was failing on unterminated JSON strings in LLM responses.
• Response handler now parses robustly with fallback extraction so a truncated completion no longer breaks the entire intake flow.

The Vercel /api/intake proxy was crashing on POST due to misconfigured proxy-to-Railway path. Fixed and load-verified.

Assessment generation was blocked on exhausted credits. Replenished to unblock the live pipeline.

SUPABASE_SERVICE_ROLE_KEY and NEXT_PUBLIC_SUPABASE_URL confirmed present and correct in the production environment.

Design doc and schema diff proving TuneView can carry GM LSA and Ford Coyote using shared flex-fuel, fuel-system, and log-channel entities. No production refactor yet — design only.

• Three tuning specialists were stuck in error state — recovered and re-activated.
• KB ingest pipeline unblocked after Railway and Vercel dashboard changes.

• Sunday's async-Supabase migration shipped a sync file handle into httpx 0.28's AsyncClient.post(content=), which rejects it.
• The upload now wraps file reads in a 64KB-chunk async generator and sets Content-Length explicitly so Supabase Storage doesn't see chunked transfer encoding.
• A regression test using httpx.MockTransport covers the path with a >64KB multi-chunk payload.

• A 24-hour kb_context_cache avoids re-fetching the same brand/platform context on every step.
• An initial_assessment_cache memoizes Round 1 assessment outputs so re-runs and retries don't re-bill the provider.
• Both backed by new Supabase tables on the lutrlvbjthgqakazjiwt project.

• App startup/shutdown moved from on_event handlers to the lifespan context manager (the deprecation FastAPI flagged in 0.95+).
• load_hptuners_csv and big_log_manager.py are now single implementations in app/; scripts/ imports the canonical version instead of carrying drift copies.

.gitignore now covers .env.local, .env.production, etc. — defense-in-depth so a local override never accidentally gets staged.

Removed the legacy '1 business day' microcopy under the submit button — superseded earlier by the live processing wall and report card from 0.8.0.

• The vehicle Round 2 page now posts to /vehicles/{id}/round2/upload on the backend.
• The old Next.js API proxy for vehicle uploads was removed so large files no longer take an extra hop through Vercel.
• The backend endpoint performs ownership checks, Supabase Storage writes, parser report generation, case creation, and run recording in one path.

The event-window cache now reuses the dataframe from the main parser path, avoiding a second CSV parse during normal report generation.

• Reports now include pipeline_timing_ms so parser, event-cache, module, research, and revision stages can be measured directly.
• The big-log event cache no longer hashes each source log twice before parsing.
• Upload parsing and storage writes are moved off the async request loop, reducing server stalls during large file handling.
• Each upload now writes its report to an isolated temporary output folder instead of the shared output/report.json path.

• The existing big-log manager now runs as a reusable parser component and writes a manifest with high-load, fuel-error, injector-pulsewidth, and shift windows.
• The pipeline adds an event_windows module plus parser_event_summary/parser_event_manifest fields to report payloads.
• Event slices use Parquet when available and fall back to CSV, so the parser cache does not depend on optional columnar libraries.

• Revision-step AI now runs only when TUNEVIEW_ENABLE_AI_REVISION=true; otherwise parser-derived revision steps are emitted.
• Round 1 assessment AI, trend interpretation, and screenshot verification also have explicit enablement flags, preventing normal site activity from silently calling Anthropic.
• Parser report cards now preserve their original severity/actionable status through normalization, so legacy parser modules still show up as useful tiles.

• The marketing intake form uploads grouped files; the backend now accepts that multi-file payload shape and records each attachment.
• The submitted-page proxy now uses NEXT_PUBLIC_API_BASE, matching the rest of the frontend/backend handoff.
• Assessment statuses are normalized so pending, triggered, and generating responses keep polling, while failed responses surface a real error.

Local development can render a deterministic report card without calling Anthropic, while live deployments can still use a funded provider key for real assessments.

• 4-outcome vocab (improved | no_change | worse | not_applied) aligned to backend.
• Authenticated POST with Supabase Bearer JWT — backend derives user_id from the token, no client-side trust.
• Real success/error states: RECORDED only on response.ok; non-200 and network failures surface an inline error instead of pretending it worked.
• Frontend done. Backend still needs to emit kb_entry_id on each RevisionStep so feedback can attribute to the specific KB entry that drove the recommendation.

tuneview.io's intake form was using NEXT_PUBLIC_API_URL while the rest of the codebase used NEXT_PUBLIC_API_BASE. Renamed to a single source of truth across both deploys.

• Replaced GM-hardcoded schema columns with multi-OEM fields: load_axis_type, vvt_architecture, single_port_varpres, tps_primary, vvt_exhaust_actual.
• Ford channel maps and Mopar tuning specialist recommendations seeded.
• The schema is now OEM-agnostic at the storage layer.

New POST /intake endpoint enables programmatic case submission from external surfaces — tuneview.io intake form is now wired through it.

GET /kb/rows now supports filter params for dedup checks before bulk ingest. A silent bug where filters were passed as a list instead of a dict (causing them to be silently dropped) has been fixed.

Structured knowledge entries from specialist researchers now flow into the canonical calibration knowledge base.

hpt_channel_aliases normalizes channel names across HPTuners platforms. 19 seed rows cover the most common divergences between OEM naming and what VCM Scanner exports.

All backend services (main app, auth, billing, embedding) now share a single Supabase client. Connection configuration drift between services eliminated.

GA4 instrumented via @next/third-parties (G-CNNSE4EHE4). Product analytics pipeline is live.

Root error and loading states added across dashboard, upload, and vehicle routes. Type errors and silent failures that were hiding behind blank screens now show actionable messages.

• The pipeline now merges two research sources: the existing rule-based matcher and a new region-locked layer that queries structured patterns from a SQLite knowledge DB.
• Region-locking means a pattern only counts if your log actually has the operating region (idle / low pedal / part throttle / WOT) it was derived from.
• The DB is optional — if it's not populated, the pipeline falls back to rule-based only. Silent fail-open, by design.

Claude now drafts a changelog entry before every session close instead of waiting to be asked. This entry is the first one it produced on its own.

• Two of the user-facing bugs above traced to the same cause.
• Two separate parts of the code each had their own answer to "is this an HPT log" — and they'd drifted apart.
• Collapsed to one. A standing rule prevents it from creeping back in.

• Errors stratified by operating region: idle / light cruise / moderate load.
• Steady vs transient flow separated — a commanded pressure ramp no longer inflates error stats.
• Duration-based filtering: one-off noise doesn't count; sustained drops under load do.
• When a sustained event fires, the module recommends checking pump duty cycle and inlet vacuum.

• Removed a dead internal API endpoint from an earlier experimental phase.
• Archived the old prototype directory after lifting its useful analytics.
• Workbench clearer.

All Python code now lives under a single app/ package. The prior dual-layout (duplicate modules at repo root and under app/) is gone. 20 root-level dev artifacts cleared out, 5 superseded duplicates deleted, 6 services migrated into app/services/ and app/parsers/. Net effect: next time something needs changing in the pipeline, there's one place to look.

The upload page went from 1990 lines to 345 by extracting types, helpers, styles, and eight subcomponents into lib/upload/ and components/upload/. Dashboard got the same treatment: 635 → 480. Nothing changed visually. Everything got easier to change without breaking.

The kb_entry_performance view — which powers the trust-weighted ordering on KB suggestions — was silently producing zero success rates because its internal outcome-string comparisons (`'worked'` / `'did_not_work'`) never matched the real values the system actually stores (`'improved'` / `'worse'`). Been broken since it shipped. Fixed in the same migration that added the KB-entry foreign key to recommendation_feedback.

The flag_low_trust_user routine — called after every feedback submission to catch bad-faith users — was silently no-opping in production because it was querying an admin-gated view as a service role. Rewrote it to call a dedicated SECURITY DEFINER RPC instead. It actually runs now.

Seven of nine SECURITY DEFINER view advisor warnings cleared. Two more remain by design — they back admin-aggregation views that legitimately need elevated privileges. Listed as a separate item to tackle when there's an admin-bypass design.

Added a kb_entry_id foreign key so feedback can finally be attributed to the specific knowledge-base entry that drove a recommendation. Row-level security aligned to the Path 1 identity model. Once feedback data starts flowing, the trust-weighted KB sort will have a real signal to operate on.