merge: NexaCloud->Odoo billing cutover (spec + plan00 hermetic suite + plan01 cancel endpoint)

Document fusion_centralize_billing as the Lago-superseding billing engine and the
isolated odoo-nexa test recipe (fresh DB + l10n_ca; never -u against live nexamain;
log_level/workers gotchas). Plan-01 doc: corrected the unsafe test command + added the
harness section.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

CLAUDE.md

@@ -35,6 +35,8 @@
 
 16. **Renaming a module's technical name needs a DB rename, not just a folder rename.** The technical name is baked into the database: `ir_module_module.name`, every external ID in `ir_model_data.module`, each view's `ir_ui_view.key` prefix, and the `ir_module_module_dependency.name` rows of every module that depends on it. Rename only the folder + in-code references and Odoo treats the new name as a fresh uninstalled module — installing it **duplicates** groups/templates/menus and **orphans** all existing data. On every DB that already has it installed, run an in-place SQL rename (the 4 tables above) **before** `-u <newname>`; a fresh DB needs nothing. Reference script + full rationale: [`fusion_portal/rename_module.sql`](fusion_portal/rename_module.sql) (written for the `fusion_authorizer_portal` → `fusion_portal` rename). Also update cross-module `depends`, `inherit_id="<old>.view"`, `t-call`, `env.ref('<old>.xmlid')`, asset paths (`<old>/static/...`), and `from odoo.addons.<old>... import`.
 
+17. **`url_encode` (and werkzeug url helpers) are NOT available in the Odoo 19 `mail.template` QWeb render context.** Using `url_encode({...})` inside a template `body_html` (e.g. to build a fallback link) makes the template fail Odoo's save-time render validation **at install**, surfacing as the opaque `ParseError: ... Oops! We couldn't save your template due to an issue with this value: <the entire body html>` (the real `NameError` is hidden, and `--log-handler odoo.tools.convert:DEBUG` does NOT reveal it). Build URLs with plain string methods instead: `'https://…?q=' + (value or '').replace(' ', '+')`. Found installing `fusion_repairs` (post-visit NPS template). **That same opaque "issue with this value" error wraps ANY render failure in a mail.template body** — when you see it, suspect an undefined name / bad field reference in the template, not malformed XML.
+
 ## Card Styling — Copy Odoo's Kanban Pattern
 Don't rely on `var(--bs-border-color)` or `var(--bs-body-bg)` for card surfaces — they drift between themes/addons and often render **invisible**. Odoo's own kanban (`.o_kanban_record`) uses **explicit hex** values:
 ```css
@@ -96,7 +98,8 @@ Odoo content-hashes the compiled bundle URL (`/web/assets/<hash>/...`). When CSS
 
 ## Module-Specific Notes
 - **fusion_clock** — developed in **Claude Code** (no longer Cursor; no concurrent-editing conflicts). Changed a lot recently (NFC kiosk: tap-to-clock, enrollment + program-from-unknown-tap, manager page, sounds, screen lock, guided profile-photo capture, faster animations). Still read files fresh before editing rather than assuming the layout. Live on entech (`odoo-entech` / LXC 111 on `pve-worker5`).
-- **fusion_repairs** — read [`fusion_repairs/cloud.md`](fusion_repairs/cloud.md) before feature work. **Version `19.0.2.2.4`.** Bundles 1–11 shipped in repo (intake, portals, dashboard, pricing, flowcharts, parts/PO). **Not production-deployed** to Westin as of 2026-05-27. Local: `docker exec odoo-modsdev-app odoo -d fusion-dev -u fusion_repairs --stop-after-init`. Outstanding: RingCentral SMS, C2 history sidebar UI, office follow-up crons (config keys only), `tests/`, more flowchart content, sales-rep dashboard tile in `fusion_portal`.
+- **fusion_repairs** — read [`fusion_repairs/cloud.md`](fusion_repairs/cloud.md) before feature work. **Version `19.0.2.3.0`** (Plan-1 maintenance foundation added 2026-06-02). **NOT Community-installable** — it transitively pulls in Enterprise `ai` + `knowledge` (`fusion_repairs → fusion_portal → fusion_claims → ai`; `fusion_portal → knowledge`), so it can NOT be installed or tested on local `odoo-modsdev` (Community) — the old `-d fusion-dev -u fusion_repairs` recipe does NOT work. **Test on Enterprise:** an isolated `westin-fr-test` DB on the `odoo-westin` host (clone of prod `westin-v19`; a fresh-DB clone install also needs a one-time orphaned-FK cleanup because prod has orphaned account/tax m2m rows). First-ever clean install surfaced + fixed 2 bugs (url_encode → rule 17; menu parent defined after its children) in commit `903ceb10`. **Not production-deployed** to Westin yet. **Test-runner gotchas on that prod-config container:** `--test-enable` SILENTLY SKIPS all tests without `--workers 0`; the conf's `log_level=warn` hides test output (add `--log-level=test`); the post_install phase also trips on a pre-existing module, so verify behaviour via `odoo shell` rather than the test runner. `mail_template_data.xml` is `noupdate=1` → template edits load on a FRESH install (the prod deploy) but NOT on `-u` of an already-installed DB. Outstanding: maintenance booking (Plan 2), visit log (Plan 3), backfill wizard (Plan 4), office follow-up crons (Plan 5), RingCentral SMS.
+- **fusion_portal** (formerly `fusion_authorizer_portal`) — authorizer/sales-rep portal; **ENTERPRISE-only** (depends `knowledge` → cannot run on local Community; verify on a westin clone, see *Westin Prod* below). **Assessment-visit flow LIVE on westin, v19.0.2.10.1.** A `fusion.assessment.visit` bundles the assessments from one home visit and, on completion (`action_complete_visit`), groups them by funding workflow (`x_fc_sale_type`) into ONE draft sale order per workflow (MoD/ADP/ODSP/WSIB/private/hardship/insurance) — never one combined SO, never one-per-item-within-a-funding. ADP devices group into one order (combination guard: ≤1 seated {wheelchair/powerchair/scooter} + ≤1 walker); accessibility items group per funding. Reps enter via the "Start a Visit" dashboard tile → `/my/visit/new`; the express/accessibility forms carry `?visit_id=` and defer SO creation to the visit. Renaming the technical name needs a DB rename — see [`fusion_portal/rename_module.sql`](fusion_portal/rename_module.sql).
 
 ## Workflow
 - Local dev: `docker exec odoo-modsdev-app odoo -d fusion-dev -u <module> --stop-after-init`
@@ -138,6 +141,19 @@ PGPASSWORD='a09e12e0995dc29446631fa458f3d4b3' psql -h 100.74.28.73 -p 5433 -U po
 - `fusionapps.code_snippets` — reference code
 - `fusionapps.quick_commands` — deployment and admin commands
 
+## Westin Prod — Deploy & Clone-Verify (fusion_portal et al.)
+
+Westin prod: host `odoo-westin`, app container `odoo-dev-app`, db container `odoo-dev-db`, DB `westin-v19` (user `odoo`, pw `DevSecure2025!`), addons `/opt/odoo/custom-addons` → `/mnt/extra-addons`, Enterprise `/mnt/enterprise-addons`, conf `/etc/odoo/odoo.conf`. ENTERPRISE env — modules depending on `knowledge` (fusion_portal → fusion_claims) cannot run on local Community, so verify on a clone before prod.
+
+**Clone-verify a change (prod-safe, isolated — prod files + live DB untouched):**
+1. Clone online: `docker exec -e PGPASSWORD='DevSecure2025!' odoo-dev-db sh -c 'dropdb -U odoo --if-exists westin-v19-visittest; createdb -U odoo -O odoo westin-v19-visittest && pg_dump -U odoo westin-v19 | psql -U odoo -q -d westin-v19-visittest'` (~2 min, ~152M -Fc).
+2. Stage the branch module into an isolated dir INSIDE the addons path: `/opt/odoo/custom-addons/_test/<module>`, then `-u <module> --stop-after-init --no-http --db_host db --db_port 5432 --db_user odoo --db_password 'DevSecure2025!' --addons-path=/usr/lib/python3/dist-packages/odoo/addons,/usr/lib/python3/dist-packages/addons,/mnt/extra-addons/_test,/mnt/enterprise-addons,/mnt/extra-addons`. The `/mnt/extra-addons/_test` prefix SHADOWS prod's copy (first matching path wins); deps load from the real `/mnt/extra-addons`.
+3. Smoke-test via `odoo shell -d westin-v19-visittest` (same addons-path); `env.cr.rollback()` at the end. To exercise email paths WITHOUT sending: `UPDATE ir_mail_server SET active=false;` AND in the shell `env['ir.mail_server'].__class__.send_email = lambda self, message, *a, **k: 'noop'` (`odoo shell` rejects `--smtp-server`).
+
+**THE ORPHANED-TAX-FK TRAP** (cost real diagnosis time): westin-v19 has ~3300 orphaned rows in `product_taxes_rel` + ~3300 in `product_supplier_taxes_rel` (`tax_id` → deleted `account_tax`), under FKs that are `convalidated=true` (taxes deleted via an FK-bypassing path; PG never re-checks a validated constraint). A plain `pg_dump | psql` clone can't recreate a *validating* FK over orphaned data → the FK is lost on the clone → Odoo `check_foreign_keys` tries to add it → `ForeignKeyViolation: Key (tax_id)=(N) is not present in account_tax` → "Failed to load registry". **Fix ON THE CLONE only:** `DELETE FROM <t> WHERE tax_id NOT IN (SELECT id FROM account_tax)` across every `%_rel` table with a tax column. **Prod `-u` is SAFE without touching the orphans** — prod's FK already exists, so Odoo skips it (it never re-validates a present FK); proven empirically by replicating FK-present+orphan on a clone and running `-u` (exit 0, orphan untouched). Owner is auditing the orphans — do NOT delete them on prod without sign-off.
+
+**Deploy:** backup (`docker exec ... pg_dump -Fc -U odoo westin-v19 > /opt/odoo/backups/<name>.dump` + `cp -r` the module dir to `/opt/odoo/backups/` — OUTSIDE the addons path, never a `*.bak` dir inside it) → `scp` branch to `/opt/odoo/staging/<module>` → swap into `/opt/odoo/custom-addons/<module>` → `-u <module>` → `DELETE FROM ir_attachment WHERE url LIKE '/web/assets/%'` → `docker restart odoo-dev-app`. **Gate the restart on `-u` exit 0**; on failure restore the dir backup and do NOT restart. When a feature branch predates main's other merges, merge to `main` **surgically** (temp worktree off `origin/main` + `git checkout <branch> -- <module>` → commit → fast-forward push) so you don't revert parallel sessions' work.
+
 ## Fusion Helpdesk — Customer Follow-up + Embedded Inbox (deployment + handoff)
 
 Two modules: **`fusion_helpdesk`** (client — runs on each client deployment, e.g. entech)
@@ -232,3 +248,41 @@ catches undefined names instantly.
   open the systray helpdesk dialog. The Mine/All toggle appears for the owner; "All" shows
   all 50 ENTECH tickets, "Mine" shows the count matching the owner's profile email.
   Tracebacks live in `/var/log/odoo/odoo-server.log` on entech (LXC 111 / pve-worker5).
+
+## Fusion Centralized Billing (`fusion_centralize_billing`) — engine + test harness
+
+Odoo (`odoo-nexa`, live DB `nexamain`) is being made the single billing brain for every
+NexaSystems app (NexaCloud, NexaDesk/Fusion-Chat, NexaMaps), **superseding Lago**. The
+module adds only the metering + integration layer (service registry, identity links,
+metric/charge catalog, aggregate-push usage engine, inbound Lago-shaped REST API at
+`/api/billing/v1/*`, outbound HMAC webhooks, dual-run reconciliation); all financial
+behaviour is native Odoo **Enterprise** (`sale_subscription` + `payment_stripe` +
+`account_accountant`). Design + rollout live in `docs/superpowers/specs/`
+(`2026-05-27-nexa-billing-centralized-design.md` = architecture;
+`2026-06-02-nexacloud-odoo-billing-cutover-design.md` = NexaCloud pilot: build → import →
+dual-run → gated flip) and `docs/superpowers/plans/`.
+
+**Testing it — NOT on local `odoo-modsdev` (community) and NEVER `-u` against live `nexamain`.**
+It needs Enterprise deps, so tests run on `odoo-nexa` in an **isolated throwaway container**
+against a **fresh** DB with the Canadian localization:
+```
+ssh odoo-nexa
+# fresh DB (inside odoo-nexa-db): dropdb --if-exists fcb_test; createdb fcb_test
+cp -a /opt/odoo/custom-addons /opt/odoo/custom-addons-staging   # edit/sync HERE, never the live module dir
+docker run --rm --network odoo_odoo-network \
+  -v /opt/odoo/custom-addons-staging:/mnt/extra-addons:ro -v /opt/odoo/enterprise-addons:/mnt/enterprise-addons:ro \
+  -v /opt/odoo/odoo.conf:/etc/odoo/odoo.conf:ro -v /opt/odoo/staging-data:/var/lib/odoo \
+  odoo-nexa:19 -c /etc/odoo/odoo.conf -d fcb_test --db_host=db --db_user=odoo \
+  --addons-path=/usr/lib/python3/dist-packages/odoo/addons,/mnt/extra-addons,/mnt/enterprise-addons \
+  --without-demo=all --test-enable --test-tags /fusion_centralize_billing \
+  -i l10n_ca,fusion_centralize_billing --stop-after-init --no-http
+```
+Iterate with `-u fusion_centralize_billing` (reuse fcb_test). Gotchas that cost hours:
+- **`l10n_ca` is required** — the ledger tests need a Canadian CoA + active CAD + 13% HST.
+- A **prod clone is the wrong base** — its existing rows collide with fixed-code test fixtures
+  (`nexacloud` service / `cpu_seconds` metric) across 5 test files.
+- odoo.conf sets `log_level=warn`, so **passing tests log nothing** — exit 0 alone does NOT
+  prove tests ran (a tag matching zero tests is also exit 0). Confirm execution with
+  `--log-handler=odoo.addons.fusion_centralize_billing.tests:INFO` (look for `Starting
+  <Class>.<method>`). The **exit code is authoritative** (1 on any failure).
+- Do **NOT** pass `--workers=0` (blanks captured stdout) or `--logfile=/dev/stdout` (errors out).

docs/plans/fusion_maintenance_brainstorm.md

@@ -0,0 +1,194 @@
+# fusion_maintenance — Brainstorm & Handoff Brief
+
+> Status: **research/brainstorm only — no code, no final decisions.** Written from a
+> Claude Code *web* session that could **not** reach the private network (no Tailscale,
+> no docker daemon, Supabase KB unreachable). Resume from a **Tailscale-connected env**
+> (dev box or a host that can reach Westin production) and do the live inspection in
+> Step 0 **before** committing to the design.
+
+## Goal (user's words, paraphrased)
+Automated maintenance follow-ups for mobility/accessibility equipment we've sold, to turn
+service into **recurring revenue**. Reminder emails → client books maintenance → booking
+happens in **real time** and **lands in our calendar**. Leverage Odoo Enterprise's
+appointment system. Decide whether this lives in `fusion_repairs` or a new module — the
+result must be **seamless and production-ready**.
+
+## Decisions locked with the user (this session)
+- **Same DB**: `fusion_claims` + `fusion_repairs` run on one database → new module may depend on both.
+- **Enterprise `appointment` is available** → build real-time booking ON it (`appointment.type` /
+  `appointment.slot` / `calendar.event`), do **not** hand-roll a calendar.
+- **Public self-serve booking** → reminder email carries a token link to a no-login slot picker
+  (extend the existing `/repairs/maintenance/book/<token>` pattern). Elderly clients shouldn't log in.
+- **Target box for grounding = Westin production** (where `fusion_claims` runs day-to-day).
+
+## Key findings from repo exploration
+
+### `fusion_repairs` (v19.0.2.2.6) ALREADY has a maintenance engine — reuse it, don't fork
+- `fusion.repair.maintenance.contract`: interval, due/last-service dates, state machine.
+  Auto-spawned on SO confirm when `product.template.x_fc_maintenance_interval_months > 0`.
+- Daily reminder cron `cron_maintenance_due_reminders` → 30/7/1-day bands → branded email
+  `email_template_maintenance_due_reminder` with tokenized link `/repairs/maintenance/book/<token>`.
+- Booking controller: `controllers/portal_maintenance_booking.py` — **single date-confirm form,
+  NO slot availability, NO conflict check, NO calendar event.** ← this is the real gap.
+- Contract **roll-forward** on technician-task completion (`next_due_date += interval`).
+- `fusion.repair.service.plan.subscription`: pre-paid visit plans (recurring-revenue primitive).
+- Deps: `repair, maintenance, sale_management, stock, purchase, website, portal, fusion_tasks,
+  fusion_poynt, fusion_authorizer_portal`. ~8.3k LOC, 25+ models.
+
+### `fusion_claims` (v19.0.9.2.0) is the ideal trigger source
+- Claim container = `sale.order` (`x_fc_sale_type`: adp, odsp, wsib, insurance, march_of_dimes, …).
+- **Equipment unit** = `sale.order.line.x_fc_serial_number` + `product_id`.
+- **Equipment category** = `fusion.adp.device.code.device_type` (wheelchair, walker, hospital bed,
+  stair lift, porch lift, custom ramp, …) — matches the user's "sale groups".
+- **Schedule anchors**: `x_fc_adp_delivery_date`, `x_fc_service_start_date`; gate on `x_fc_adp_approved`.
+- Customer = `sale.order.partner_id`; prescriber = `x_fc_authorizer_id`.
+- Already depends on `calendar, fusion_tasks, ai, fusion_ringcentral`.
+
+## Proposed architecture (PENDING live verification)
+**New module `fusion_maintenance`** depending on `fusion_repairs`, `fusion_claims`, `appointment`.
+Reuses the existing contract/reminder/roll-forward engine; adds the 3 genuinely-missing pieces:
+
+1. **`fusion.maintenance.policy`** (ops-configurable, no code per category):
+   `device_type` → `interval_months`, reminder bands, `service_product_id` (priced visit),
+   `appointment_type_id`, required technician skill. Turns "stair lift = 6 mo, $X" into data.
+2. **Claims bridge** (daily cron): scan `fusion_claims` `sale.order.line` for delivered+approved
+   devices whose `device_type` matches an active policy → ensure a maintenance contract exists,
+   anchored at `delivery_date + interval`. Idempotent (key on serial / sale-line). Extend the
+   reused contract with `x_fc_source_claim_line_id`, `x_fc_device_type`, `x_fc_policy_id` so the
+   repairs path and claims path both feed **one** contract model.
+3. **Real-time booking on `appointment`**: token link → slot picker backed by `appointment.type`
+   (partner pre-resolved from token, no login). Slot pick → real `calendar.event` → hook spawns
+   `repair.order` + technician task, assigns by skill/zone, advances reminder band, rolls contract
+   forward.
+
+**Recurring revenue**: each policy carries `service_product_id` → booked visit drafts a priced
+SO/invoice; optional pre-paid annual plan via existing `service.plan.subscription`; optional
+door payment via existing `fusion_poynt`.
+
+## STEP 0 — run on Westin production FIRST (grounding before any decision)
+> Replace `APP`/`DB` with the real Westin container + database. CLAUDE.md rule #1: never code
+> from memory — read the real Enterprise `appointment` source before building the booking layer.
+
+```bash
+# RESOLVED 2026-06-02 — Westin Odoo prod migrated OFF Digital Ocean onto the on-prem Proxmox
+# cluster. Old DO IPs (152.42.146.204 / 178.128.229.92) are DEAD (:22 timeout). Live box:
+# host `odoo-westin` = 192.168.1.40 via the `supabase-prod` Tailscale jump (Windows OpenSSH
+# ProxyCommand → run `ssh odoo-westin ...` from PowerShell). App container `odoo-dev-app`
+# (odoo:19, Enterprise); DB container `odoo-dev-db`; DB `westin-v19`; user `odoo` (local-socket
+# trust inside odoo-dev-db). Enterprise addons → /mnt/enterprise-addons, custom → /mnt/extra-addons.
+#   SQL:      ssh odoo-westin 'docker exec odoo-dev-db  psql -U odoo -d westin-v19 -c "..."'
+#   FS read:  ssh odoo-westin 'docker exec odoo-dev-app sed -n 1,160p /mnt/enterprise-addons/...'
+APP=odoo-dev-app ; DB=westin-v19 ; DBC=odoo-dev-db
+
+# 1) Install matrix — confirm same-DB + Enterprise appointment present + versions
+docker exec "$APP" psql -U odoo -d "$DB" -c \
+"SELECT name,state,latest_version FROM ir_module_module \
+ WHERE name IN ('fusion_claims','fusion_repairs','fusion_maintenance','calendar','maintenance','repair') \
+    OR name LIKE 'appointment%' ORDER BY name;"
+
+# 2) Real device_type distribution (drives per-category policies)
+docker exec "$APP" psql -U odoo -d "$DB" -c \
+"SELECT device_type, count(*) FROM fusion_adp_device_code GROUP BY device_type ORDER BY 2 DESC;"
+
+# 3) Locate the Enterprise appointment source (read, don't guess the API)
+docker exec "$APP" bash -lc 'ls -d /mnt/enterprise-addons/appointment 2>/dev/null || \
+  find / -maxdepth 6 -type d -name appointment 2>/dev/null | grep -i addons | head'
+
+# 4) Appointment model surface to build booking on (adjust path from #3)
+docker exec "$APP" cat <appointment_path>/models/appointment_type.py | head -160
+docker exec "$APP" ls <appointment_path>/controllers/    # find the public booking controller
+
+# 5) How fusion_repairs maintenance contracts already look in live data
+docker exec "$APP" psql -U odoo -d "$DB" -c \
+"SELECT state, count(*) FROM fusion_repair_maintenance_contract GROUP BY state;"
+```
+
+## STEP 0 — RESULTS (ran 2026-06-02 against Westin prod `westin-v19`)
+> Grounding facts only — **no design decisions made**. These correct several assumptions above.
+
+**Connection (resolved):** host `odoo-westin` (192.168.1.40) via the `supabase-prod` Tailscale jump.
+App container `odoo-dev-app` (odoo:19, Enterprise), DB container `odoo-dev-db`, DB `westin-v19`,
+user `odoo`. Old Digital Ocean boxes are DEAD — Westin migrated on-prem.
+
+**1) Install matrix** — `appointment` **19.0.1.3 installed** (+ `appointment_account_payment`,
+`_crm`, `_hr`, `_microsoft_calendar`, `_sms`). All deps present: `calendar`, `maintenance`, `repair`,
+`sale_management`, `portal`, `website`, `resource`, `phone_validation`, `web_gantt`. `fusion_claims`
+**19.0.9.2.0 installed**. `fusion_repairs` and `fusion_maintenance` are **absent entirely** (no
+records). → a module depending on `appointment` installs cleanly; "reuse the fusion_repairs engine"
+means *deploy fusion_repairs to Westin first* (heavy) **or** own a lean contract model here. Note
+Odoo's native `maintenance` (CMMS) is installed — an under-considered third reuse option.
+
+**2) device_type** — 119 distinct values, but `fusion.adp.device.code` is the ADP billing-code
+**CATALOG** (`_order='device_type, device_code'`), so counts are catalog codes per type, **NOT units
+installed**. Top entries are seating COMPONENTS (Seat Cushion 564, Back Support 375, Headrest 193).
+The maintainable **equipment classes** ≈ wheelchairs (manual + power tilt), power bases, power
+scooters, wheeled walkers / walking frames, paediatric standing frames, specialty strollers (~6-8
+clean categories). → `device_type` can't be a 1:1 policy key (119 values, mostly parts); needs a
+grouping/whitelist. **Real install base sized on `sale.order.line`** (`x_fc_adp_device_type` [stored compute from
+product's `x_fc_adp_device_code_id.device_type`], `x_fc_serial_number`, `x_fc_adp_approved`; delivery
+dates `x_fc_adp_delivery_date` / `x_fc_service_start_date`) — **see the Install-base sizing block below.**
+
+**3) + 4) Enterprise appointment source** — `/mnt/enterprise-addons/appointment`. The no-login token
+slot-picker is **mostly NATIVE — don't hand-roll it**: public booking (`auth="public"`), invite
+tokens (`appointment.invite`, `/appointment/<id>?…invite_token`), live availability
+(`/appointment/<id>/update_available_slots`, jsonrpc/public), slot submit → real `calendar.event`
+(`/appointment/<id>/submit`), auto/manual staff+resource assignment, capacity, booked/cancelled mail
+templates. Model `appointment.type`; controller `controllers/appointment.py`. → the module mainly
+needs to: seed an `appointment.type` per category, drop a partner-bound invite link into the reminder
+email, and hook `calendar.event` create → spawn the service task + advance the contract.
+`appointment_account_payment` is installed → native pay-to-book is on the table for the revenue mechanic.
+
+**5) Maintenance-contract state** — `relation "fusion_repair_maintenance_contract" does not exist`
+→ confirms the fusion_repairs maintenance engine is **not** on Westin.
+
+**Headline correction:** Westin's ADP data has **zero** stair lifts / porch lifts / ramps / hospital
+beds — those belong to the fusion_repairs / EN-Tech (mobility) domain. Westin's recurring-revenue
+play is **wheelchairs / power bases / scooters / walkers / seating**. Open questions updated below.
+
+**Install-base sizing (ran 2026-06-02 — the REAL units, complementing #2's catalog counts).** Big tell:
+serial numbers are captured **~only on actual equipment** (every part/option/mod device_type shows 0
+serials), so `x_fc_serial_number` is already a de-facto "trackable unit" marker — convenient, because the
+bridge's idempotency key is the serial.
+
+- **Addressable base ≈ 138 serial-tracked units across ~136 customers** (all funders). By equipment
+  family (serial-tracked / of which delivered): **Walkers & walking frames 68 (55)**, **Wheelchairs 45
+  (40)**, **Power bases 7 (6)**, **Scooters 4 (3)**, plus **14 units with no ADP device_type** (likely
+  private-pay) and 1 misc.
+- **Funder split** (serial-tracked): adp 109, direct_private 13, adp_odsp 10, march_of_dimes 7;
+  wsib / insurance / standalone-odsp / rental / regular = **0 serials**. → an ADP-only gate
+  (`x_fc_adp_approved`) captures ~110 and **misses ~28** real units. The bridge should likely key on
+  **serial (funder-agnostic)**, not approval.
+- **Two data gaps the design must absorb:** (a) the 14 serial units with no ADP device_type can't be
+  classified by a device_type→policy map → need a product-level or manual category override; (b) non-ADP
+  units have no `x_fc_adp_delivery_date` → the contract anchor (`delivery_date + interval`) needs a
+  fallback (invoice/order date).
+- Deliveries span **2022-10 → 2026-05** (active program) — history to anchor intervals + a live pipeline.
+- Top serial-tracked device_types: Adult Wheeled Walker Type 3 (47), Adult Manual Dynamic Tilt Type 5
+  Wheelchair (23), Adult Lightweight Performance Type 3 (11), Adult Lightweight Standard Type 1 (10),
+  Adult Wheeled Walker Type 2 (9), Adult Power Base Type 3 (5), Power Scooter (3). (1 line ≈ 1 unit;
+  equipment device_types are 1 base line each.)
+
+## Open questions to resolve with the user (in the connected session)
+- **MVP cut**: which categories first? Sizing surfaces a real tension: **by volume** it's walkers (68) +
+  wheelchairs (45) ≈ 82% of the base, but rollators/walkers are mechanically low-service; **by
+  service-revenue-per-unit** the targets are the powered units (power bases 7 + scooters 4 + power
+  wheelchairs) — high maintenance value but only ~11–15 units today. Volume vs. margin — or phase it
+  (powered units first to prove the booking loop, then walkers/manual chairs for reach)?
+- **Revenue mechanic**: auto-draft a priced SO/invoice per booking, vs. pre-paid annual plan, vs.
+  pay-at-door via Poynt — which is the default?
+- **Technician assignment**: auto-assign by skill+zone at booking time, or leave dispatch manual
+  (fusion_tasks) and only reserve the calendar slot?
+- **Booking-portal strategy**: Step 0 shows Enterprise `appointment` already ships public,
+  token-based real-time booking (`appointment.invite` + `/appointment/<id>/...`, `auth="public"`).
+  Ride on that (generate an invite per reminder, partner pre-bound, no login) vs. a custom
+  `/maintenance/book/<token>` route? (The `/repairs/...` route is moot — fusion_repairs isn't on Westin.)
+
+## Applicable CLAUDE.md rules (don't relearn the hard way)
+- Rule #1: read reference files from the running instance before coding (esp. the appointment source).
+- Odoo 19: `res.users.group_ids` (not `groups_id`); `ir.cron` has no `numbercall`; declarative
+  `models.Constraint`/`models.Index`; HTTP routes `type="jsonrpc"`; OWL uses standalone `rpc()`.
+- No `sale.subscription` model exists — a subscription is a `sale.order` with `is_subscription=True`.
+- New fields use `x_fc_` prefix; Canadian English; `$` Monetary + `currency_id`.
+- Route attachment opens through `fusion_pdf_preview` (`att.action_fusion_preview(...)`).
+- Tests need `--http-port=0 --gevent-port=0`. Westin prod is Enterprise; local dev is Community
+  (so the appointment-dependent module can't be installed/tested on `odoo-modsdev-app`).

docs/superpowers/plans/2026-06-02-accessibility-funding-selector.md

@@ -0,0 +1,43 @@
+# Accessibility Funding-Source Selector — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: superpowers:executing-plans (inline) — this is a 3-file change. Steps use `- [ ]` checkboxes.
+
+**Goal:** Let the rep mark an accessibility assessment's funding source (Private / March of Dimes / ODSP / WSIB / Hardship / Insurance / Other) on the web form, so the generated sale order routes to the correct funding pipeline instead of always defaulting to private pay.
+
+**Architecture:** The model (`fusion.accessibility.assessment.x_fc_funding_source`) and the SO routing (`_create_draft_sale_order` → `sale_type_map` → `x_fc_sale_type`) already exist (the "2026-04 portal audit fix"). The only gaps: (1) the form has no funding field, (2) the save controller never reads `funding_source` from the POST, (3) `hardship` is missing from the selectable funding sources. The submit JS already serialises every named form field via `FormData`, so no JS change is needed.
+
+**Tech Stack:** Odoo 19, QWeb portal template, JSON-RPC controller. Module `fusion_portal` (worktree `K:\Github\Odoo-Modules-wt-portal`, branch `feat/assessment-visit`).
+
+**Verification constraint:** `fusion_portal` depends on Enterprise `knowledge`, so it can NOT be installed on the local Community Docker. Syntax-check with host Python; functional verification is on westin (or a clone): pick "March of Dimes" on a form → the draft SO gets `x_fc_sale_type='march_of_dimes'` and lands in the MOD pipeline.
+
+---
+
+### Task 1: Add Hardship to the funding source + route it
+
+**Files:** Modify `fusion_portal/models/accessibility_assessment.py` (selection ~:71-87, `sale_type_map` ~:771-779)
+
+- [ ] **Step 1:** Add `('hardship', 'Hardship Funding')` to the `x_fc_funding_source` selection list (after `'wsib'`).
+- [ ] **Step 2:** Add `'hardship': 'hardship',` to `sale_type_map` in `_create_draft_sale_order` (the target `x_fc_sale_type='hardship'` already exists in `fusion_claims` `sale_order.py:332`).
+- [ ] **Step 3:** `python -m py_compile fusion_portal/models/accessibility_assessment.py` → no error.
+- [ ] **Step 4:** Commit.
+
+### Task 2: Add the funding select to the shared client-info form
+
+**Files:** Modify `fusion_portal/views/portal_accessibility_templates.xml` (`accessibility_client_info_section`, ~:366-375)
+
+- [ ] **Step 1:** Add a new row with a `<select name="funding_source">` (options mirror the model selection; `direct_private` pre-selected so existing private behaviour is unchanged) right after the phone/email row, before the card closes.
+- [ ] **Step 2:** Validate XML well-formedness (`[xml]` parse).
+- [ ] **Step 3:** Commit.
+
+### Task 3: Capture funding_source in the save controller
+
+**Files:** Modify `fusion_portal/controllers/portal_main.py` (`accessibility_assessment_save` vals, ~:2498-2511)
+
+- [ ] **Step 1:** Add `'x_fc_funding_source': post.get('funding_source') or 'direct_private',` to the `vals` dict.
+- [ ] **Step 2:** `python -m pyflakes fusion_portal/controllers/portal_main.py` → no new undefined-name errors.
+- [ ] **Step 3:** Commit.
+
+### Task 4: Verify + ship
+
+- [ ] **Step 1:** Grep confirms `funding_source` flows form → controller → `x_fc_funding_source` → `sale_type_map`.
+- [ ] **Step 2:** Deploy to westin (backup → scp the 3 files → `-u fusion_portal` → cache-bust → restart) and confirm: open `/my/accessibility/stairlift/straight`, pick "March of Dimes", complete → the new SO shows `x_fc_sale_type = march_of_dimes` and appears in the MOD pipeline.

docs/superpowers/plans/2026-06-02-fusion-maintenance-foundation.md

@@ -0,0 +1,506 @@
+# fusion_maintenance Foundation — Implementation Plan (Plan 1 of 5)
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Confirming a sale of a maintainable product auto-creates a *priced* maintenance contract, and the due-reminder email shows the maintenance cost.
+
+**Architecture:** Extend `fusion_repairs`. A maintenance **policy** (enabled / interval / flat fee) lives on `fusion.repair.product.category`, with a per-product fee/interval override on `product.template`. We fix the dead `_spawn_maintenance_contracts()` (anchor on delivery date, capture serial + fee + provenance, dedup) and call it from the **existing** `action_confirm()` override. The branded reminder email gains a fee line.
+
+**Tech Stack:** Odoo 19 **Community**, Python, `TransactionCase`. Local dev: `docker odoo-modsdev-app`, DB `fusion-dev`.
+
+**Spec:** [`2026-06-02-fusion-maintenance-design.md`](../specs/2026-06-02-fusion-maintenance-design.md). This is **Plan 1 of 5**; see the Roadmap at the bottom for Plans 2–5 (booking, visit log, backfill, office crons) — each is written when reached because it needs its own live-source reads (spec §15).
+
+**Conventions (from CLAUDE.md):** new fields `x_fc_` prefix; Canadian English; Monetary = `$` + `currency_id`; declarative `models.Constraint` / `models.Index` (no `_sql_constraints`); `message_post` HTML wrapped in `Markup()`; `res.users` group field is `group_ids`.
+
+**Run tests:**
+```bash
+docker exec odoo-modsdev-app odoo -d fusion-dev --test-enable --test-tags /fusion_repairs \
+  -u fusion_repairs --stop-after-init --http-port=0 --gevent-port=0 2>&1 | tail -60
+```
+
+**Grounding (verified source, 2026-06-02):**
+- [`maintenance_contract.py`](../../../fusion_repairs/models/maintenance_contract.py) — contract model (fields end at `company_id`, line 81; `_booking_token_unique` constraint line 83); dead `_spawn_maintenance_contracts()` (line 198, anchors on `today`, dedups by partner/product/SO, no fee/serial/source).
+- [`repair_product_category.py`](../../../fusion_repairs/models/repair_product_category.py) — category model; `safety_critical`, `equipment_class`; `_code_unique` constraint line 56.
+- [`product_template.py`](../../../fusion_repairs/models/product_template.py) — `x_fc_repair_category_id` (line 11), `x_fc_maintenance_interval_months` (line 23, default 0).
+- [`repair_service_plan.py`](../../../fusion_repairs/models/repair_service_plan.py) — **existing** `action_confirm()` override (line 229) ending `return res` (line 250); wire the maintenance spawn here.
+
+---
+
+## File Structure
+
+- **Modify** `fusion_repairs/models/repair_product_category.py` — add maintenance-policy fields + `currency_id`.
+- **Modify** `fusion_repairs/models/product_template.py` — add `x_fc_maintenance_fee` override.
+- **Modify** `fusion_repairs/models/maintenance_contract.py` — add contract fields + indexes; add `_fc_maintenance_anchor_date`; rewrite `_spawn_maintenance_contracts`.
+- **Modify** `fusion_repairs/models/repair_service_plan.py` — call `self._spawn_maintenance_contracts()` inside `action_confirm`.
+- **Modify** `fusion_repairs/data/mail_template_data.xml` — add a fee row to the reminder template.
+- **Modify** `fusion_repairs/views/repair_product_category_views.xml` — expose the policy fields.
+- **Create** `fusion_repairs/tests/__init__.py`, `fusion_repairs/tests/test_maintenance_foundation.py`.
+- **Modify** `fusion_repairs/__manifest__.py` — bump `version` to `19.0.2.3.0`.
+
+> **Scope note:** the technician-skill field (`x_fc_maintenance_skill_id`) is deferred to **Plan 2 (booking)** because skill matching is a booking concern and the exact skills representation is an open item (spec §15). Plan 1 is enrollment + pricing only.
+
+---
+
+## Task 1: Maintenance policy fields on the equipment category
+
+**Files:**
+- Modify: `fusion_repairs/models/repair_product_category.py` (insert after `intake_template_id`, before `_code_unique` at line 56)
+- Test: `fusion_repairs/tests/test_maintenance_foundation.py`
+
+- [ ] **Step 1: Create the tests package + write the failing test**
+
+Create `fusion_repairs/tests/__init__.py`:
+```python
+from . import test_maintenance_foundation
+```
+
+Create `fusion_repairs/tests/test_maintenance_foundation.py`:
+```python
+# -*- coding: utf-8 -*-
+from odoo.tests import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install')
+class TestMaintenanceFoundation(TransactionCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.partner = cls.env['res.partner'].create({'name': 'Mrs. Test Client'})
+        cls.category = cls.env['fusion.repair.product.category'].create({
+            'name': 'Stair Lift', 'code': 'stairlift',
+            'equipment_class': 'lift_elevating', 'safety_critical': True,
+            'x_fc_maintenance_enabled': True,
+            'x_fc_maintenance_interval_months': 6,
+            'x_fc_maintenance_fee': 149.0,
+        })
+
+    def test_category_policy_fields_exist(self):
+        self.assertTrue(self.category.x_fc_maintenance_enabled)
+        self.assertEqual(self.category.x_fc_maintenance_interval_months, 6)
+        self.assertEqual(self.category.x_fc_maintenance_fee, 149.0)
+        self.assertTrue(self.category.currency_id)
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run:
+```bash
+docker exec odoo-modsdev-app odoo -d fusion-dev --test-enable --test-tags /fusion_repairs -u fusion_repairs --stop-after-init --http-port=0 --gevent-port=0 2>&1 | tail -40
+```
+Expected: FAIL — `Invalid field 'x_fc_maintenance_enabled' on model 'fusion.repair.product.category'`.
+
+- [ ] **Step 3: Add the policy fields**
+
+In `repair_product_category.py`, insert before the `_code_unique = models.Constraint(...)` line:
+```python
+    # ── Maintenance policy (per equipment type) ──────────────────────────
+    x_fc_maintenance_enabled = fields.Boolean(
+        string='Offer Maintenance',
+        help='If set, units in this category are enrolled in recurring preventive '
+             'maintenance on sale (and via the backfill wizard).',
+    )
+    x_fc_maintenance_interval_months = fields.Integer(
+        string='Maintenance Interval (Months)', default=6,
+        help='Default months between preventive maintenance visits for this category. '
+             'Overridden by the product field of the same name when that is > 0.',
+    )
+    currency_id = fields.Many2one(
+        'res.currency', string='Currency',
+        default=lambda self: self.env.company.currency_id,
+    )
+    x_fc_maintenance_fee = fields.Monetary(
+        string='Maintenance Fee', currency_field='currency_id',
+        help='Flat fee shown to the client for a maintenance visit of this equipment type.',
+    )
+    x_fc_maintenance_service_product_id = fields.Many2one(
+        'product.product', string='Maintenance Service Product',
+        help='Optional product used when drafting the priced visit line (Plan 2). '
+             'Falls back to a generic visit product.',
+    )
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run the same command as Step 2. Expected: `test_category_policy_fields_exist` PASS.
+
+- [ ] **Step 5: Commit**
+```bash
+git add fusion_repairs/models/repair_product_category.py fusion_repairs/tests/
+git commit -m "feat(fusion_repairs): maintenance policy fields on equipment category"
+```
+
+---
+
+## Task 2: Per-product fee override
+
+**Files:**
+- Modify: `fusion_repairs/models/product_template.py` (after `x_fc_maintenance_interval_months`, line 28)
+- Test: `fusion_repairs/tests/test_maintenance_foundation.py`
+
+- [ ] **Step 1: Write the failing test** (append to the test class)
+```python
+    def test_product_fee_override_field_exists(self):
+        tmpl = self.env['product.template'].create({
+            'name': 'Handicare Freecurve Stairlift',
+            'x_fc_repair_category_id': self.category.id,
+            'x_fc_maintenance_fee': 199.0,
+        })
+        self.assertEqual(tmpl.x_fc_maintenance_fee, 199.0)
+```
+
+- [ ] **Step 2: Run to verify it fails**
+
+Run the test command. Expected: FAIL — `Invalid field 'x_fc_maintenance_fee' on model 'product.template'`.
+
+- [ ] **Step 3: Add the field**
+
+In `product_template.py`, after the `x_fc_maintenance_interval_months` field (line 28):
+```python
+    x_fc_maintenance_fee = fields.Monetary(
+        string='Maintenance Fee (override)', currency_field='currency_id',
+        help='Per-product override of the category maintenance fee. 0 = use the category fee.',
+    )
+```
+(`product.template` already provides `currency_id`.)
+
+- [ ] **Step 4: Run to verify it passes** — `test_product_fee_override_field_exists` PASS.
+
+- [ ] **Step 5: Commit**
+```bash
+git add fusion_repairs/models/product_template.py fusion_repairs/tests/test_maintenance_foundation.py
+git commit -m "feat(fusion_repairs): per-product maintenance fee override"
+```
+
+---
+
+## Task 3: Contract model extensions (fee, source, serial, policy)
+
+**Files:**
+- Modify: `fusion_repairs/models/maintenance_contract.py` (add fields after `company_id`, line 81; add indexes near `_booking_token_unique`, line 83)
+- Test: `fusion_repairs/tests/test_maintenance_foundation.py`
+
+- [ ] **Step 1: Write the failing test**
+```python
+    def test_contract_extension_fields_exist(self):
+        c = self.env['fusion.repair.maintenance.contract'].create({
+            'partner_id': self.partner.id,
+            'product_id': self.env['product.product'].create({'name': 'Unit'}).id,
+            'next_due_date': '2026-12-01',
+            'x_fc_source': 'sale',
+            'x_fc_device_serial': 'SN-123',
+            'x_fc_maintenance_fee': 149.0,
+        })
+        self.assertEqual(c.x_fc_source, 'sale')
+        self.assertEqual(c.x_fc_device_serial, 'SN-123')
+        self.assertEqual(c.x_fc_maintenance_fee, 149.0)
+```
+
+- [ ] **Step 2: Run to verify it fails** — `Invalid field 'x_fc_source' ...`.
+
+- [ ] **Step 3: Add the fields + indexes**
+
+In `maintenance_contract.py`, after the `company_id` field (line 81), before `_booking_token_unique`:
+```python
+    currency_id = fields.Many2one(
+        'res.currency', default=lambda self: self.env.company.currency_id,
+    )
+    x_fc_maintenance_fee = fields.Monetary(
+        string='Maintenance Fee', currency_field='currency_id',
+        help='Flat fee shown to the client for this maintenance visit.',
+    )
+    x_fc_source = fields.Selection(
+        [('sale', 'New Sale'), ('backfill', 'Backfill'),
+         ('claims', 'Claims Bridge'), ('manual', 'Manual')],
+        string='Source', default='manual', index=True,
+    )
+    x_fc_source_sale_line_id = fields.Many2one(
+        'sale.order.line', string='Source Sale Line', index=True, copy=False,
+    )
+    x_fc_device_serial = fields.Char(string='Serial (text)', index=True, copy=False)
+    x_fc_policy_category_id = fields.Many2one(
+        'fusion.repair.product.category', string='Maintenance Policy',
+    )
+```
+(Idempotency is enforced in Python — Task 4 — to support the two-regime dedup in spec §6.2; the `index=True` above covers lookups.)
+
+- [ ] **Step 4: Run to verify it passes** — `test_contract_extension_fields_exist` PASS.
+
+- [ ] **Step 5: Commit**
+```bash
+git add fusion_repairs/models/maintenance_contract.py fusion_repairs/tests/test_maintenance_foundation.py
+git commit -m "feat(fusion_repairs): maintenance contract fee/source/serial/policy fields"
+```
+
+---
+
+## Task 4: Spawn priced contracts on sale confirm (fix the dead trigger + wire it)
+
+**Files:**
+- Modify: `fusion_repairs/models/maintenance_contract.py` (rewrite `_spawn_maintenance_contracts`, lines 198-227; add `_fc_maintenance_anchor_date` helper)
+- Modify: `fusion_repairs/models/repair_service_plan.py` (call it in `action_confirm`, before `return res` at line 250)
+- Test: `fusion_repairs/tests/test_maintenance_foundation.py`
+
+- [ ] **Step 1: Write the failing tests**
+```python
+    def _make_product(self, **kw):
+        vals = {'name': 'Stairlift Unit', 'type': 'consu',
+                'x_fc_repair_category_id': self.category.id}
+        vals.update(kw)
+        return self.env['product.product'].create(vals)
+
+    def _confirm_so(self, product, commitment='2026-01-10'):
+        so = self.env['sale.order'].create({
+            'partner_id': self.partner.id,
+            'commitment_date': commitment,
+            'order_line': [(0, 0, {'product_id': product.id, 'product_uom_qty': 1})],
+        })
+        so.action_confirm()
+        return so
+
+    def _contracts_for(self, so):
+        return self.env['fusion.repair.maintenance.contract'].search(
+            [('original_sale_order_id', '=', so.id)])
+
+    def test_no_contract_when_category_not_maintainable(self):
+        cat = self.env['fusion.repair.product.category'].create(
+            {'name': 'Cane', 'code': 'cane', 'x_fc_maintenance_enabled': False})
+        so = self._confirm_so(self._make_product(x_fc_repair_category_id=cat.id))
+        self.assertFalse(self._contracts_for(so))
+
+    def test_contract_created_via_category_policy(self):
+        so = self._confirm_so(self._make_product())
+        contracts = self._contracts_for(so)
+        self.assertEqual(len(contracts), 1)
+        c = contracts
+        self.assertEqual(c.interval_months, 6)
+        self.assertEqual(c.x_fc_maintenance_fee, 149.0)
+        self.assertEqual(c.x_fc_source, 'sale')
+        self.assertEqual(c.x_fc_policy_category_id, self.category)
+        # anchor = commitment_date + 6 months
+        self.assertEqual(str(c.next_due_date), '2026-07-10')
+
+    def test_product_override_beats_category(self):
+        p = self._make_product()
+        p.product_tmpl_id.x_fc_maintenance_interval_months = 3
+        p.product_tmpl_id.x_fc_maintenance_fee = 199.0
+        so = self._confirm_so(p)
+        c = self._contracts_for(so)
+        self.assertEqual(c.interval_months, 3)
+        self.assertEqual(c.x_fc_maintenance_fee, 199.0)
+
+    def test_idempotent_on_reconfirm(self):
+        p = self._make_product()
+        so = self._confirm_so(p)
+        so._spawn_maintenance_contracts()  # call again
+        self.assertEqual(len(self._contracts_for(so)), 1)
+```
+
+- [ ] **Step 2: Run to verify they fail** — contracts not created (trigger not wired) → assertions fail.
+
+- [ ] **Step 3: Rewrite `_spawn_maintenance_contracts` + add the anchor helper**
+
+Replace the body of `_spawn_maintenance_contracts` (lines 198-227) and add the helper, in the `SaleOrder` class of `maintenance_contract.py`:
+```python
+    def _fc_maintenance_anchor_date(self, line):
+        """Best-available delivery anchor: commitment_date -> date_order -> today.
+        (Non-ADP/lift units lack a delivery date; this fallback chain handles them.)"""
+        so = line.order_id
+        anchor = so.commitment_date or so.date_order
+        return fields.Date.to_date(anchor) if anchor else fields.Date.context_today(self)
+
+    def _spawn_maintenance_contracts(self):
+        """Create a priced maintenance contract per maintainable unit on a confirmed SO.
+        Policy = product interval override, else the product's category policy.
+        Idempotent: by serial when captured, else by source sale line."""
+        Contract = self.env['fusion.repair.maintenance.contract'].sudo()
+        for so in self:
+            if so.state not in ('sale', 'done'):
+                continue
+            for line in so.order_line:
+                product = line.product_id
+                if not product:
+                    continue
+                tmpl = product.product_tmpl_id
+                category = tmpl.x_fc_repair_category_id
+                product_interval = tmpl.x_fc_maintenance_interval_months or 0
+                cat_enabled = bool(category) and category.x_fc_maintenance_enabled
+                interval = product_interval or (
+                    category.x_fc_maintenance_interval_months if cat_enabled else 0)
+                if interval <= 0 or not (product_interval > 0 or cat_enabled):
+                    continue
+                fee = tmpl.x_fc_maintenance_fee or (
+                    category.x_fc_maintenance_fee if category else 0.0)
+                # Capture serial only if fusion_claims' line field is present.
+                serial = ''
+                if 'x_fc_serial_number' in line._fields:
+                    serial = (line.x_fc_serial_number or '').strip()
+                # Idempotency: serial regime vs source-line regime (spec §6.2).
+                if serial:
+                    dedup = [('state', '=', 'active'), ('x_fc_device_serial', '=', serial)]
+                else:
+                    dedup = [('state', '=', 'active'),
+                             ('x_fc_source_sale_line_id', '=', line.id)]
+                if Contract.search_count(dedup):
+                    continue
+                anchor = so._fc_maintenance_anchor_date(line)
+                # One contract per serialized unit; without a serial, per quantity.
+                count = 1 if serial else max(int(line.product_uom_qty or 1), 1)
+                for _i in range(count):
+                    Contract.create({
+                        'partner_id': so.partner_id.id,
+                        'product_id': product.id,
+                        'original_sale_order_id': so.id,
+                        'x_fc_source_sale_line_id': line.id,
+                        'x_fc_source': 'sale',
+                        'x_fc_device_serial': serial,
+                        'x_fc_policy_category_id': category.id if category else False,
+                        'interval_months': interval,
+                        'x_fc_maintenance_fee': fee,
+                        'next_due_date': anchor + relativedelta(months=interval),
+                        'state': 'active',
+                    })
+```
+
+- [ ] **Step 4: Wire it into the existing `action_confirm`**
+
+In `repair_service_plan.py`, in `action_confirm`, change line 249-250 from:
+```python
+        self._fc_spawn_labor_warranties()
+        return res
+```
+to:
+```python
+        self._fc_spawn_labor_warranties()
+        self._spawn_maintenance_contracts()
+        return res
+```
+
+- [ ] **Step 5: Run to verify the Task-4 tests pass** — all four PASS.
+
+- [ ] **Step 6: Commit**
+```bash
+git add fusion_repairs/models/maintenance_contract.py fusion_repairs/models/repair_service_plan.py fusion_repairs/tests/test_maintenance_foundation.py
+git commit -m "feat(fusion_repairs): spawn priced maintenance contracts on sale confirm"
+```
+
+---
+
+## Task 5: Show the fee in the reminder email
+
+**Files:**
+- Modify: `fusion_repairs/data/mail_template_data.xml` (the `email_template_maintenance_due_reminder` record)
+
+- [ ] **Step 1: Read the current template**
+
+Run:
+```bash
+docker exec odoo-modsdev-app sh -c "grep -n 'email_template_maintenance_due_reminder' /mnt/odoo-modules/fusion_repairs/data/mail_template_data.xml"
+```
+Then open that record's `<field name="body_html">` and find the equipment-name / due-date details table (the green-accent reminder).
+
+- [ ] **Step 2: Add a fee row to the details table**
+
+Inside the details table of the reminder body, after the "Next due" row, add (Canadian English, `$` + currency):
+```xml
+<tr t-if="object.x_fc_maintenance_fee">
+  <td style="opacity:0.6;width:35%;">Maintenance fee</td>
+  <td><span t-field="object.x_fc_maintenance_fee"
+            t-options='{"widget": "monetary", "display_currency": object.currency_id}'/>
+      <span style="opacity:0.6;"> + applicable tax</span></td>
+</tr>
+```
+
+- [ ] **Step 3: Upgrade + manually verify the rendered email**
+
+Run:
+```bash
+docker exec odoo-modsdev-app odoo -d fusion-dev -u fusion_repairs --stop-after-init
+```
+Then in odoo-shell render the template for a contract with a fee and confirm the fee line appears:
+```bash
+docker exec odoo-modsdev-app odoo shell -d fusion-dev --no-http <<'PY'
+c = env['fusion.repair.maintenance.contract'].search([('x_fc_maintenance_fee','>',0)], limit=1)
+tpl = env.ref('fusion_repairs.email_template_maintenance_due_reminder')
+print('FEE' if 'applicable tax' in tpl._render_field('body_html', c.ids)[c.id] else 'MISSING')
+PY
+```
+Expected: `FEE`.
+
+- [ ] **Step 4: Commit**
+```bash
+git add fusion_repairs/data/mail_template_data.xml
+git commit -m "feat(fusion_repairs): show maintenance fee in due-reminder email"
+```
+
+---
+
+## Task 6: Expose policy fields in the category form + bump version
+
+**Files:**
+- Modify: `fusion_repairs/views/repair_product_category_views.xml`
+- Modify: `fusion_repairs/__manifest__.py`
+
+- [ ] **Step 1: Read the category form view**
+
+Run:
+```bash
+docker exec odoo-modsdev-app sh -c "grep -n 'fusion.repair.product.category' /mnt/odoo-modules/fusion_repairs/views/repair_product_category_views.xml | head"
+```
+Locate the `<form>` for the category.
+
+- [ ] **Step 2: Add a Maintenance group to the form**
+
+Inside the category form sheet, add:
+```xml
+<group string="Maintenance Policy">
+    <field name="x_fc_maintenance_enabled"/>
+    <field name="x_fc_maintenance_interval_months"
+           invisible="not x_fc_maintenance_enabled"/>
+    <field name="x_fc_maintenance_fee"
+           invisible="not x_fc_maintenance_enabled"/>
+    <field name="x_fc_maintenance_service_product_id"
+           invisible="not x_fc_maintenance_enabled"/>
+    <field name="currency_id" invisible="1"/>
+</group>
+```
+
+- [ ] **Step 3: Bump the version**
+
+In `fusion_repairs/__manifest__.py`, change `'version': '19.0.2.2.6',` to `'version': '19.0.2.3.0',`.
+
+- [ ] **Step 4: Upgrade + run the full test module green**
+
+Run:
+```bash
+docker exec odoo-modsdev-app odoo -d fusion-dev --test-enable --test-tags /fusion_repairs -u fusion_repairs --stop-after-init --http-port=0 --gevent-port=0 2>&1 | tail -40
+```
+Expected: all `TestMaintenanceFoundation` tests PASS, 0 failures, module loads.
+
+- [ ] **Step 5: Commit**
+```bash
+git add fusion_repairs/views/repair_product_category_views.xml fusion_repairs/__manifest__.py
+git commit -m "feat(fusion_repairs): category maintenance-policy UI + version 19.0.2.3.0"
+```
+
+---
+
+## Self-Review (against the spec)
+
+- **Spec §2 D2 (flat fee per type):** Tasks 1-2 (policy on category + product override), Task 4 (fee snapshot on contract), Task 5 (fee in email). ✓
+- **Spec §3.2 gap #1 (dead trigger):** Task 4 fixes + wires `_spawn_maintenance_contracts`. ✓
+- **Spec §3.2 gap #3 (no cost shown):** Task 5. ✓
+- **Spec §5.1 / §5.2 (policy + contract fields):** Tasks 1-3. ✓
+- **Spec §6.1 (new-sale path, delivery anchor, idempotent, serial when present):** Task 4 (`_fc_maintenance_anchor_date`, two-regime dedup, guarded serial capture). ✓
+- **Deferred to Plan 2:** `x_fc_maintenance_skill_id` (skills representation is §15 open item) — noted in File Structure.
+- **No placeholders:** every code step shows complete code; the two "read first" steps (Tasks 5-6) target XML whose exact surrounding markup must be read live before editing, and give the exact snippet to insert.
+- **Type consistency:** `x_fc_maintenance_fee` Monetary + `currency_id` used identically on category, product, contract; `_spawn_maintenance_contracts` / `_fc_maintenance_anchor_date` names consistent between maintenance_contract.py and the call site in repair_service_plan.py.
+
+---
+
+## Roadmap — Plans 2–5 (write each when reached; each needs its own live-source reads per spec §15)
+
+- **Plan 2 — Technician-aware booking** (the largest build): read `fusion_tasks/models/technician_task.py` `_find_next_available_slot` (line 544) / `_get_available_gaps` (line 664) signatures + working-hours source; add `x_fc_maintenance_skill_id` to the category and confirm the `res.users.x_fc_repair_skills` representation; replace the `<input type="date">` booking page with a real slot-picker controller; on confirm create a `fusion.technician.task` (`task_type='maintenance'`) + the maintenance `repair.order`; double-book guard; office "Book maintenance" action; per-cycle `booking_token` regen in `roll_next_due_date`. Delivers: real self-serve booking.
+- **Plan 3 — Maintenance visit log + checklist**: read the visit-report wizard + the inspection-certificate (M1) API; add `fusion.repair.maintenance.visit` + `fusion.repair.maintenance.checklist.line`; seed checklists per category; issue an inspection certificate for `safety_critical` categories. Delivers: queryable per-unit history + compliance proof.
+- **Plan 4 — Backfill wizard** (two-regime, spec §6.2): `fusion.repair.maintenance.backfill.wizard`; serial dedup for ADP wheelchairs (guarded `fusion_claims` read), partner+base-product+sale-line dedup for lifts with accessory-line exclusion; stagger; dry-run report → execute. Delivers: the existing install base enrolled.
+- **Plan 5 — Office follow-up crons**: `unbooked` + `overdue` crons gated on the existing `ir.config_parameter` toggles; per-row savepoint isolation. Delivers: staff nudges when clients don't self-serve.

docs/superpowers/plans/2026-06-02-nexacloud-cutover-01-odoo-cancel-endpoint.md

@@ -0,0 +1,298 @@
+# NexaCloud→Odoo Cutover — Plan 01: Odoo subscription-cancel endpoint
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add the one inbound endpoint NexaCloud's deprovision path needs — cancel (close) a subscription — to `fusion_centralize_billing`, with the same auth model the other endpoints already use.
+
+**Architecture:** New `fusion.billing.service._api_cancel_subscription(external_ref)` resolves the subscription via the existing `_fc_resolve_subscription`, enforces the same "partner must be linked to this service" authorization as `_api_record_usage`, and closes it with Odoo 19's native `set_close()` (→ `subscription_state='6_churn'`). A `DELETE /api/billing/v1/subscriptions/<ref>` route wraps it.
+
+**Tech Stack:** Odoo 19 Enterprise (`sale_subscription`), Python, Odoo `TransactionCase` tests.
+
+**Spec:** [`2026-06-02-nexacloud-odoo-billing-cutover-design.md`](../specs/2026-06-02-nexacloud-odoo-billing-cutover-design.md) §4.1.3
+
+---
+
+## ⚠ Test harness (supersedes any `-d nexamain` command below)
+
+**NEVER run `-u` / `--test-enable` against the live `nexamain` DB.** Tests run in an **isolated throwaway container** against a dedicated DB, reading a **separate** addons copy so the live module is never touched:
+
+```
+# 1) edit files on branch feat/nexacloud-odoo-billing-cutover, then sync the changed
+#    module files to the staging addons copy on odoo-nexa:
+#      /opt/odoo/custom-addons-staging/fusion_centralize_billing/...
+# 2) run (ssh odoo-nexa):
+docker run --rm --network odoo_odoo-network \
+  -v /opt/odoo/custom-addons-staging:/mnt/extra-addons:ro \
+  -v /opt/odoo/enterprise-addons:/mnt/enterprise-addons:ro \
+  -v /opt/odoo/odoo.conf:/etc/odoo/odoo.conf:ro \
+  -v /opt/odoo/staging-data:/var/lib/odoo \
+  odoo-nexa:19 -c /etc/odoo/odoo.conf -d fcb_test \
+  --db_host=db --db_user=odoo \
+  --addons-path=/usr/lib/python3/dist-packages/odoo/addons,/mnt/extra-addons,/mnt/enterprise-addons \
+  --test-enable --test-tags /fusion_centralize_billing:TestSubscriptionCancel \
+  -u fusion_centralize_billing --stop-after-init --no-http
+```
+- `fcb_test` is a **fresh** install DB (not a prod clone). `nexamain_staging` is a prod clone kept for later integration/importer plans.
+- **Scope each step's run to the relevant test class** (`:TestSubscriptionCancel`, `:TestSubscriptionCancelHttp`). The wider suite is **not hermetic yet** (see Plan 00) — `test_invoice_ledger` needs a configured Canadian CoA/active CAD/HST; `test_usage`/`test_webhook` collide with cloned prod data. Don't gate this plan on those.
+- The per-step `Run:` blocks below that mention `-d nexamain` are **illustrative only — use this harness instead.**
+
+> **Prerequisite — Plan 00 (make the suite hermetic):** before green-baseline TDD, fix fixtures so the whole suite passes on `fcb_test`: `setUp` should get-or-create the `nexacloud`/`cpu_seconds` records (idempotent), and a test-setup helper must ensure an active CAD currency + a Canadian CoA + a 13% HST sale tax. Tracked as its own plan; recommended before Plan 01 execution.
+
+---
+
+## Increment plan sequence (this is Plan 01 of 6)
+
+Each is its own plan doc + its own working, testable deliverable. Order reflects dependencies:
+
+1. **Odoo: subscription-cancel endpoint** ← *this doc* (unblocked; no external decisions).
+2. **Odoo: NexaCloud charge catalog** — products + `sale.subscription.plan` (`NC-PLAN-*`) + `fusion.billing.charge` (cpu_seconds quota/overage). **Blocked on confirming real NexaCloud plan pricing/quotas** (open review Q#1) before it can be written placeholder-free.
+3. **Odoo: importer go-forward subscriptions** — extend `wizards/import_wizard.py` to create one shadow `sale.order` per active deployment with go-forward `next_invoice_date`; the safety test that asserts **no past-period invoice** is the centrepiece (guards against the 2026-05-27 Lago re-bill).
+4. **NexaCloud: adapter activation** — config (`odoo_billing_base_url`/`api_key`/staged enable), customer + subscription create/cancel calls, reconciliation-amount push.
+5. **NexaCloud: control-loop receiver** — activate `/billing/webhooks/central` HMAC verify → suspend/restore/deprovision via `network_isolation`/`throttle_checker`/`resource_manager`.
+6. **Dual-run + gated flip** — operational runbook: shadow ≥1 cycle, reconcile to cent, then the reversible flip flag.
+
+---
+
+## File structure (this plan)
+
+- Modify: `fusion_centralize_billing/models/service.py` — add `_api_cancel_subscription`.
+- Modify: `fusion_centralize_billing/controllers/api.py` — add `DELETE /subscriptions/<ref>`.
+- Create: `fusion_centralize_billing/tests/test_subscription_cancel.py` — service-method + authorization tests.
+- Modify: `fusion_centralize_billing/tests/__init__.py` — import the new test module.
+
+Run tests (from `K:\Github\CLAUDE.md` workflow, adapted to odoo-nexa):
+```
+ssh odoo-nexa "docker exec odoo-nexa-app odoo -d nexamain --test-enable --test-tags /fusion_centralize_billing -u fusion_centralize_billing --stop-after-init"
+```
+
+---
+
+### Task 1: `_api_cancel_subscription` service method
+
+**Files:**
+- Modify: `fusion_centralize_billing/models/service.py` (add method after `_api_create_subscription`, ~line 250)
+- Create: `fusion_centralize_billing/tests/test_subscription_cancel.py`
+- Modify: `fusion_centralize_billing/tests/__init__.py`
+
+- [ ] **Step 0: Verify the Odoo 19 close method (do NOT code from memory — per `K:\Github\CLAUDE.md`)**
+
+Run:
+```
+ssh odoo-nexa "docker exec odoo-nexa-app grep -nE 'def set_close|def set_open|6_churn' /mnt/enterprise-addons/sale_subscription/models/sale_order.py | head"
+```
+Expected: a `def set_close(self...)` exists and sets `subscription_state='6_churn'`. If the method name differs in this build, use the actual name in Step 3 and the assertion in Step 1.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `fusion_centralize_billing/tests/test_subscription_cancel.py`:
+```python
+# -*- coding: utf-8 -*-
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install')
+class TestSubscriptionCancel(TransactionCase):
+
+    def setUp(self):
+        super().setUp()
+        self.plan = self.env['sale.subscription.plan'].sudo().create(
+            {'name': 'Monthly', 'billing_period_value': 1, 'billing_period_unit': 'month'})
+        self.product = self.env['product.product'].sudo().create(
+            {'name': 'NexaCloud Plan', 'type': 'service',
+             'recurring_invoice': True, 'list_price': 49.0})
+        self.svc_a = self.env['fusion.billing.service'].sudo().create(
+            {'name': 'NexaCloud', 'code': 'nexacloud'})
+        self.svc_b = self.env['fusion.billing.service'].sudo().create(
+            {'name': 'Other', 'code': 'other'})
+        self.svc_a._api_upsert_customer({'external_id': 'user-1', 'name': 'Acme'})
+        res = self.svc_a._api_create_subscription({
+            'external_customer_id': 'user-1', 'plan_id': self.plan.id,
+            'lines': [{'product_id': self.product.id, 'quantity': 1}]})
+        self.sub = self.env['sale.order'].browse(res['subscription_id'])
+
+    def test_cancel_closes_subscription(self):
+        self.assertEqual(self.sub.subscription_state, '3_progress')
+        res = self.svc_a._api_cancel_subscription(str(self.sub.id))
+        self.assertEqual(res['status'], 'ok')
+        self.assertEqual(self.sub.subscription_state, '6_churn')
+
+    def test_cancel_is_idempotent(self):
+        self.svc_a._api_cancel_subscription(str(self.sub.id))
+        res = self.svc_a._api_cancel_subscription(str(self.sub.id))
+        self.assertEqual(res['status'], 'ok')
+        self.assertEqual(self.sub.subscription_state, '6_churn')
+
+    def test_cancel_unknown_subscription_rejected(self):
+        res = self.svc_a._api_cancel_subscription('999999999')
+        self.assertEqual(res['status'], 'error')
+        self.assertEqual(res['error'], 'unknown subscription')
+
+    def test_cancel_cross_service_rejected(self):
+        # svc_b is not linked to the customer that owns self.sub
+        res = self.svc_b._api_cancel_subscription(str(self.sub.id))
+        self.assertEqual(res['status'], 'error')
+        self.assertEqual(res['error'], 'unknown subscription')
+        self.assertEqual(self.sub.subscription_state, '3_progress')
+
+    def test_cancel_missing_id_rejected(self):
+        res = self.svc_a._api_cancel_subscription('')
+        self.assertEqual(res['status'], 'error')
+```
+
+Append to `fusion_centralize_billing/tests/__init__.py`:
+```python
+from . import test_subscription_cancel
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run:
+```
+ssh odoo-nexa "docker exec odoo-nexa-app odoo -d nexamain --test-enable --test-tags /fusion_centralize_billing:TestSubscriptionCancel -u fusion_centralize_billing --stop-after-init"
+```
+Expected: FAIL — `AttributeError: 'fusion.billing.service' object has no attribute '_api_cancel_subscription'`.
+
+- [ ] **Step 3: Implement the method**
+
+In `fusion_centralize_billing/models/service.py`, add immediately after `_api_create_subscription`:
+```python
+    def _api_cancel_subscription(self, external_ref):
+        """Cancel (close) the subscription identified by ``external_ref``.
+
+        Authorization mirrors ``_api_record_usage``: the resolved sale.order must
+        exist, be a subscription, and belong to a customer THIS service is linked
+        to. Idempotent — closing an already-churned subscription returns ok.
+        Validation (C3): an empty ref returns a 4xx-shaped error, never raises.
+        """
+        self.ensure_one()
+        if external_ref in (None, ''):
+            return {'status': 'error', 'error': 'subscription id required'}
+        sub = self._fc_resolve_subscription(external_ref)
+        linked_partners = self.account_link_ids.mapped('partner_id')
+        if not sub.exists() or not sub.is_subscription \
+                or sub.partner_id not in linked_partners:
+            return {'status': 'error', 'error': 'unknown subscription'}
+        if sub.subscription_state != '6_churn':
+            sub.set_close()
+        return {'status': 'ok', 'subscription_id': sub.id,
+                'subscription_state': sub.subscription_state}
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run:
+```
+ssh odoo-nexa "docker exec odoo-nexa-app odoo -d nexamain --test-enable --test-tags /fusion_centralize_billing:TestSubscriptionCancel -u fusion_centralize_billing --stop-after-init"
+```
+Expected: PASS — 5 tests, 0 failures. (If `set_close()` was a different name in Step 0, use that name here and re-run.)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_centralize_billing/models/service.py fusion_centralize_billing/tests/test_subscription_cancel.py fusion_centralize_billing/tests/__init__.py
+git commit -m "feat(billing): add _api_cancel_subscription (close sub, service-scoped authz)"
+```
+
+---
+
+### Task 2: `DELETE /subscriptions/<ref>` route
+
+**Files:**
+- Modify: `fusion_centralize_billing/controllers/api.py` (add route after `post_subscription`, ~line 95)
+- Modify: `fusion_centralize_billing/tests/test_subscription_cancel.py` (add an HTTP-layer test)
+
+- [ ] **Step 1: Write the failing test (HTTP layer)**
+
+Append to `tests/test_subscription_cancel.py` a class that exercises the route through Odoo's test client. Add the import at the top of the file:
+```python
+from odoo.tests import HttpCase
+```
+Then append:
+```python
+@tagged('post_install', '-at_install')
+class TestSubscriptionCancelHttp(HttpCase):
+
+    def setUp(self):
+        super().setUp()
+        self.plan = self.env['sale.subscription.plan'].sudo().create(
+            {'name': 'Monthly', 'billing_period_value': 1, 'billing_period_unit': 'month'})
+        self.product = self.env['product.product'].sudo().create(
+            {'name': 'NexaCloud Plan', 'type': 'service',
+             'recurring_invoice': True, 'list_price': 49.0})
+        self.svc = self.env['fusion.billing.service'].sudo().create(
+            {'name': 'NexaCloud', 'code': 'nexacloud'})
+        self.raw_key = self.svc.action_generate_api_key()
+        self.svc._api_upsert_customer({'external_id': 'user-1', 'name': 'Acme'})
+        res = self.svc._api_create_subscription({
+            'external_customer_id': 'user-1', 'plan_id': self.plan.id,
+            'lines': [{'product_id': self.product.id, 'quantity': 1}]})
+        self.sub_id = res['subscription_id']
+        self.env.cr.commit()
+        self.addCleanup(self._cleanup)
+
+    def _cleanup(self):
+        self.env['sale.order'].browse(self.sub_id).sudo().unlink()
+
+    def test_delete_requires_auth(self):
+        resp = self.url_open(
+            "/api/billing/v1/subscriptions/%s" % self.sub_id,
+            method='DELETE')
+        self.assertEqual(resp.status_code, 401)
+
+    def test_delete_cancels_with_valid_key(self):
+        resp = self.url_open(
+            "/api/billing/v1/subscriptions/%s" % self.sub_id,
+            method='DELETE',
+            headers={'Authorization': 'Bearer %s' % self.raw_key})
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.json()['subscription_state'], '6_churn')
+```
+
+- [ ] **Step 2: Run the test to verify it fails**
+
+Run:
+```
+ssh odoo-nexa "docker exec odoo-nexa-app odoo -d nexamain --test-enable --test-tags /fusion_centralize_billing:TestSubscriptionCancelHttp -u fusion_centralize_billing --stop-after-init"
+```
+Expected: FAIL — the DELETE route returns 404 (route not registered) so the assertions fail.
+
+- [ ] **Step 3: Implement the route**
+
+In `fusion_centralize_billing/controllers/api.py`, add after `post_subscription`:
+```python
+    @http.route(f"{API_BASE}/subscriptions/<sub_ref>", type="http", auth="none",
+                methods=["DELETE"], csrf=False)
+    def delete_subscription(self, sub_ref, **kw):
+        service = self._authenticate()
+        if not service:
+            return self._json({"error": "unauthorized"}, status=401)
+        result = service._api_cancel_subscription(sub_ref)
+        if result.get("status") == "error":
+            status = 404 if result.get("error") == "unknown subscription" else 400
+            return self._json(result, status=status)
+        return self._json(result)
+```
+
+- [ ] **Step 4: Run the test to verify it passes**
+
+Run:
+```
+ssh odoo-nexa "docker exec odoo-nexa-app odoo -d nexamain --test-enable --test-tags /fusion_centralize_billing:TestSubscriptionCancelHttp -u fusion_centralize_billing --stop-after-init"
+```
+Expected: PASS — 2 tests, 0 failures.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_centralize_billing/controllers/api.py fusion_centralize_billing/tests/test_subscription_cancel.py
+git commit -m "feat(billing): DELETE /api/billing/v1/subscriptions/<ref> cancel route"
+```
+
+---
+
+## Self-review
+
+- **Spec coverage:** §4.1.3 "add subscription cancel (`DELETE /subscriptions/:id`)" → Tasks 1+2. ✔
+- **Placeholder scan:** none — all code is concrete; Step 0 verifies the one Odoo-internal name (`set_close`) against the live container instead of assuming.
+- **Type consistency:** `_api_cancel_subscription` returns the same `{'status','subscription_id','subscription_state'}` shape as `_api_create_subscription`; error shape matches `_api_record_usage` (`{'status':'error','error':...}`); resolver reused (`_fc_resolve_subscription`) so cross-service rejection is identical to `/usage`. ✔
+- **Authorization parity:** cancel uses the exact `not sub.exists() or not sub.is_subscription or sub.partner_id not in linked_partners` guard as `_api_record_usage`. ✔

docs/superpowers/specs/2026-06-02-fusion-maintenance-design.md

@@ -0,0 +1,298 @@
+# fusion_maintenance — Design Spec
+
+> Automated preventive‑maintenance follow‑ups + self‑serve real‑time booking for Westin
+> medical mobility equipment (stair lifts, porch lifts, lift chairs, wheelchairs, power
+> wheelchairs/scooters), to keep clients on schedule and turn service into recurring revenue.
+
+| | |
+|---|---|
+| **Status** | Design **approved** (brainstorm dialogue 2026‑06‑02). Ready for implementation plan. |
+| **Implemented by** | **Extending `fusion_repairs`** (no new module). Version bump. |
+| **Target instance** | Westin production — host `odoo-westin` (192.168.1.40), container `odoo-dev-app`, DB `westin-v19`. One company / one DB running `fusion_claims` (live) + `fusion_repairs` (to be deployed). |
+| **Relates to** | [`docs/plans/fusion_maintenance_brainstorm.md`](../../plans/fusion_maintenance_brainstorm.md) (brief + Step 0 + sizing), [`2026-05-20-fusion-repairs-design.md`](2026-05-20-fusion-repairs-design.md) (base module). |
+| **Next step** | `writing-plans` → implementation plan. **No code until the plan is written and this spec is reviewed.** |
+
+---
+
+## 1. Goal
+
+Westin sells/services mobility equipment that needs preventive maintenance every **1–6 months
+depending on the product**. Today there is no system keeping clients on schedule. We want:
+
+1. The system **automatically emails the client** when a unit is due for maintenance.
+2. The client can **book the visit themselves** (real‑time, self‑serve, no login) **or** call the
+   office and staff book it for them.
+3. The booking **lands in our scheduling/calendar** as a real technician job.
+4. The **technician accesses and updates the maintenance log** on the visit; the system keeps the
+   full history per unit.
+5. The **next maintenance is auto‑rescheduled** → recurring loop.
+6. The client is **told the cost** up front.
+7. Outcome: clients stay on track **and** Westin gains **recurring revenue**.
+8. Design/UX stays **consistent with `fusion_claims`** (branded emails, `x_fc_` naming, Canadian
+   English, `$`+`currency_id`).
+
+## 2. Locked decisions (from the brainstorm)
+
+| # | Decision | Choice | Why |
+|---|----------|--------|-----|
+| D1 | Separate module vs. part of `fusion_repairs` | **Build into `fusion_repairs`** | The maintenance engine already lives there (~90% built); a separate module would duplicate it. fusion_repairs already owns the equipment categories, `repair.order`, technician tasks, service plans, and the Westin rate card. |
+| D2 | Pricing / revenue model | **Flat fee per equipment type** | Transparent cost to show the client; recurring per‑visit revenue. Configured per equipment **category** with per‑product override. |
+| D3 | Enrollment scope | **New sales + backfill existing install base** | The recurring revenue and "keep clients on track" value is in the *existing* base, not just future sales. |
+| D4 | Booking engine | **Technician‑aware picker on `fusion_tasks`** (NOT Enterprise `appointment`) | Clients see only slots a qualified tech is genuinely free for (route/skill‑aware); booking creates the technician task directly — one scheduling world, no appointment↔task bridge. Bonus: **no Enterprise dependency → Community‑testable locally.** |
+
+## 3. Grounding (verified, not assumed)
+
+### 3.1 What `fusion_repairs` ALREADY has (reuse — do not rebuild)
+Source: [`fusion_repairs/models/maintenance_contract.py`](../../../fusion_repairs/models/maintenance_contract.py), [`technician_task.py`](../../../fusion_repairs/models/technician_task.py), [`repair_service_plan.py`](../../../fusion_repairs/models/repair_service_plan.py), `cloud.md`.
+
+- `fusion.repair.maintenance.contract` — partner/product/lot/original_SO, `interval_months`,
+  `last_service_date`, `next_due_date`, state machine (`draft/active/paused/cancelled`),
+  `booking_token` (unique), `last_reminder_band`, `booking_repair_id`. `roll_next_due_date()`
+  advances the cycle correctly via `relativedelta`.
+- Reminder cron `cron_send_due_reminders` — daily, **30/7/1‑day** bands, per‑band dedup, queued
+  branded email `email_template_maintenance_due_reminder` with the tokenized link.
+- Public booking controller `/repairs/maintenance/book/<token>` — `auth='public'`, token‑validated,
+  already‑booked guard, thanks page.
+- `create_repair_from_booking()` — spawns a `repair.order` (`x_fc_intake_source='client_portal'`),
+  links `x_fc_maintenance_contract_id`, dedups.
+- **Roll‑forward** on technician task completion ([`technician_task.py:88`](../../../fusion_repairs/models/technician_task.py:88)): when a `task_type='maintenance'` task → `status='completed'`, sets `last_service_date`, calls `roll_next_due_date()`, posts chatter. **This is the recurring loop.**
+- Pre‑paid **service‑plan subscriptions** (`fusion.repair.service.plan.subscription`) wired to
+  `sale.order.action_confirm()` + visit burn engine (revenue primitive; optional here).
+- **Rate card** (`fusion.repair.callout.rate`, standard vs `lift_elevating`), `repair.order.x_fc_quote_total`.
+- **Equipment category taxonomy** (`fusion.repair.product.category`): stairlift / porch_lift /
+  lift_chair flagged `equipment_class=lift_elevating`, `safety_critical=True`.
+- **Inspection certificate** (`fusion.repair.inspection.certificate`, M1 — Done): PDF + expiry cron.
+- Visit‑report wizard (signature, parts, labour timer).
+- `product.template.x_fc_maintenance_interval_months` (exists, [product_template.py:23](../../../fusion_repairs/models/product_template.py:23)).
+- `fusion_tasks` availability engine: [`_find_next_available_slot(tech_id, date, ...)`](../../../fusion_tasks/models/technician_task.py:544) and [`_get_available_gaps(tech_id, date, ...)`](../../../fusion_tasks/models/technician_task.py:664) — **route‑aware** (tech start address + geocoding + travel). Tech skills on `res.users.x_fc_repair_skills`.
+
+### 3.2 The 4 gaps this spec closes
+1. **Contract auto‑creation trigger is dead code** — `_spawn_maintenance_contracts()` is defined on
+   `sale.order` ([maintenance_contract.py:198](../../../fusion_repairs/models/maintenance_contract.py:198)) but **never called**. No `action_confirm` override invokes it → no contracts exist today.
+2. **No real booking** — the booking page is a bare `<input type="date">` ("a team member will call
+   to confirm"); no availability, no slots, no calendar/task. **This is the main new build.**
+3. **No cost shown to the client** anywhere (email or booking page).
+4. **No auto tech‑task creation, no structured maintenance log, no office‑follow‑up crons**
+   (`ir.config_parameter` toggles exist; no cron/Python).
+
+### 3.3 Install‑base sizing (Westin live, 2026‑06‑02)
+- Serial numbers are captured **~only on real equipment** (parts have 0 serials) → `x_fc_serial_number`
+  is a de‑facto "trackable unit" marker and the natural **idempotency key**.
+- ADP‑side base ≈ **138 serial‑tracked units / ~136 customers** (walkers 68, wheelchairs 45, power
+  bases 7, scooters 4, +14 no‑device‑type). Funders: adp 109, direct_private 13, adp_odsp 10,
+  march_of_dimes 7. Deliveries 2022‑10 → 2026‑05.
+- **Lifts (sized 2026‑06‑02; name‑based, approximate)** — a LARGE base in Westin's Odoo: stair lifts
+  ~254 customers (416 lines incl. accessories), porch/VPL ~30 customers (75 lines), lift chairs ~41
+  customers (47 lines) — real products (Access BDD, Handicare, Serenity VPL, Pride VivaLift). **But lift
+  serial coverage is ~0** (12/416 stairlift lines, 0 VPL, 2 lift‑chair). So the serial‑as‑unit‑key
+  approach that works for ADP wheelchairs **does NOT work for lifts** — lifts must be keyed by
+  (partner + base‑unit product + sale line), excluding accessory lines (curves, rails, remotes, charging
+  stations, rentals). This splits the backfill into two regimes (§6.2).
+- Two backfill data gaps: 14 units have no device_type (need product/manual category); non‑ADP units
+  lack `x_fc_adp_delivery_date` (need an invoice/order‑date fallback anchor).
+
+## 4. Architecture
+
+Extend `fusion_repairs`. No new module, no new top‑level dependency for the core flow (booking uses
+`fusion_tasks`, already a hard dep; pricing/Poynt already deps). The optional `fusion_claims` read
+for the wheelchair backfill is a **soft** dependency (guarded `if 'fusion.claims' model present`),
+so `fusion_repairs` still installs/test‑runs without `fusion_claims` on local dev.
+
+Reuse map: contract engine (extend), `fusion.technician.task` (booking target + availability +
+roll‑forward), `repair.order` (visit container/pricing/Poynt), inspection certificate (lift
+compliance), visit‑report wizard (extend with checklist), branded email pattern, rate card.
+
+## 5. Data model
+
+All new fields `x_fc_`, Canadian English labels, Monetary = `$` + `currency_id`.
+
+### 5.1 Maintenance policy — on `fusion.repair.product.category` ("per equipment type")
+- `x_fc_maintenance_enabled` (Boolean) — is this category maintainable?
+- `x_fc_maintenance_interval_months` (Integer) — default cadence (1–6+).
+- `x_fc_maintenance_fee` (Monetary, `currency_id`) — the **flat fee** shown to the client.
+- `x_fc_maintenance_skill_id` — the technician skill the booking matches on (maps to
+  `res.users.x_fc_repair_skills`). **If skills are already category‑based** (a tech's
+  `x_fc_repair_skills` are equipment categories), drop this field and simply match technicians whose
+  skills include *this* category — confirm the skills representation before modelling (§15).
+- `x_fc_maintenance_service_product_id` (M2O `product.product`, optional) — the service product used
+  when drafting the priced invoice/SO line; falls back to a generic "Maintenance visit" product.
+
+**Per‑product override:** `product.template.x_fc_maintenance_interval_months` (exists) +
+new `product.template.x_fc_maintenance_fee` (Monetary, optional). Resolution order at contract
+creation: product override → category policy.
+
+### 5.2 Extend `fusion.repair.maintenance.contract`
+- `x_fc_maintenance_fee` (Monetary) — resolved price snapshot, shown to client.
+- `x_fc_source` (Selection: `sale` / `backfill` / `claims` / `manual`).
+- `x_fc_source_sale_line_id` (M2O `sale.order.line`) — provenance + idempotency.
+- `x_fc_device_serial` (Char, indexed) — idempotency key (esp. for claims/backfill where no lot).
+- `x_fc_policy_category_id` (M2O `fusion.repair.product.category`).
+- Constraint: at most one **active** contract per `(x_fc_device_serial)` (or per source sale line
+  when serial absent) — declarative `models.Constraint` / partial `models.Index`.
+
+### 5.3 New `fusion.repair.maintenance.visit` (the log)
+A structured, queryable per‑visit record — *not* buried in chatter.
+- `contract_id` (M2O, required), `technician_task_id` (M2O `fusion.technician.task`),
+  `repair_order_id` (M2O `repair.order`, the container), `partner_id`, `product_id`, `lot_id`.
+- `visit_date`, `technician_id` (res.users), `state` (`scheduled/in_progress/done/no_show/cancelled`).
+- `checklist_line_ids` (O2M to `fusion.repair.maintenance.checklist.line`: label, result
+  `pass/fail/na`, note) — items seeded **per equipment category** (lift checklist ≠ wheelchair
+  checklist).
+- `findings` (Html, `Markup()`), `parts_note`, `x_fc_fee` (Monetary), `signature` (Binary),
+  `inspection_certificate_id` (M2O — set for `safety_critical` categories).
+- "log/history" view = the list of visits per contract/unit (smart button on contract + partner).
+
+## 6. Enrollment — two paths
+
+### 6.1 Path A — new sales (fix the dead trigger)
+Override `sale.order.action_confirm()` to call `_spawn_maintenance_contracts()` (reuse the existing
+method; fix + wire it). For each confirmed line whose product/category has
+`x_fc_maintenance_enabled` and a serial/lot:
+- Create one `active` contract per unit (respect quantity), `x_fc_source='sale'`,
+  `x_fc_source_sale_line_id` set, serial captured.
+- `next_due_date = (delivery/commitment date or date_order) + interval` (fallback chain handles
+  non‑ADP units lacking a delivery date).
+- Resolve + snapshot `x_fc_maintenance_fee`.
+- **Idempotent**: skip if an active contract already exists for the serial / sale line.
+
+### 6.2 Path B — backfill existing install base (one‑time wizard, idempotent)
+`fusion.repair.maintenance.backfill.wizard`:
+- **Scan** historical `sale.order.line` for products whose category/product is maintenance‑enabled and
+  were delivered. **Two unit‑identity regimes**, because lifts carry no serials (§3.3):
+  - **Serial‑tracked** (ADP wheelchairs/power chairs, via the `fusion_claims` serial/`device_type` data
+    — soft dep, guarded; map ADP `device_type` → maintenance category): require a serial, **dedup by serial**.
+  - **Non‑serial** (lifts — stair/porch/VPL/lift‑chair): do **NOT** require a serial. One contract per
+    **base‑unit line**, **dedup by (partner + maintainable product + source sale line)**. The per‑product
+    `x_fc_maintenance_enabled` flag is what includes base units and **excludes accessory lines** (curves,
+    rails, remotes, charging stations, rentals) — only the lift itself gets a contract, not its add‑ons.
+- **Stagger** the first `next_due_date` across a configurable window (e.g. spread overdue units over
+  N weeks) so years of equipment don't all email on day one.
+- **Dry‑run first**: produce a report (counts by category, # new vs already‑enrolled, # skipped for
+  missing serial/date, the stagger schedule). Nothing is created or emailed until the operator
+  approves and runs "Execute".
+- Anchor fallback for units with no delivery date: invoice date → order date → today.
+
+## 7. Booking flow (the main build)
+
+### 7.1 Client self‑serve (no login)
+1. Reminder email (existing branded template, **+ fee line added**) → tokenized link.
+2. Public slot‑picker page (extend the existing `/repairs/maintenance/book/<token>` route; replace
+   the date input). The page:
+   - Resolves the contract from the token; shows unit + **flat fee** ("$X + applicable tax").
+   - Computes candidate technicians = users whose `x_fc_repair_skills` include the policy's
+     `x_fc_maintenance_skill_id`.
+   - Calls `fusion_tasks` `_get_available_gaps` / `_find_next_available_slot` per candidate tech over
+     the next ~2–3 weeks, ranked by **proximity** to the client address → presents a short list of
+     real open slots (date + window + implied tech).
+3. Client picks a slot → POST confirm:
+   - **Re‑validate** the slot is still free (gap check) — if taken/expired, re‑render slots with a
+     gentle notice (prevents double‑booking).
+   - Create a `fusion.technician.task` (`task_type='maintenance'`) on that slot, **assigned to the
+     qualified tech** (auto‑assignment by availability+skill), linked to the contract.
+   - Spawn/link the maintenance‑type `repair.order` (container) + the `fusion.repair.maintenance.visit`
+     (state `scheduled`, checklist seeded from the category).
+   - Send the branded confirmation email (date/window/tech, fee, what to expect).
+   - Set `booking_repair_id` (dedup).
+4. **No‑slot fallback:** if no qualified tech/slot in range → show "request a callback" → create an
+   office activity. Never a dead end.
+
+### 7.2 Office books on the client's behalf
+- A **"Book maintenance"** action on the `fusion.repair.maintenance.contract` form opens the same
+  slot‑picker logic in the backend (office books while on the phone).
+- The existing dispatch board remains available for manual scheduling/override.
+
+### 7.3 Token security fix
+On `roll_next_due_date()`, **regenerate `booking_token`** (currently it is not regenerated, so an
+old link stays valid across cycles). Old token → friendly "link expired" page.
+
+## 8. Cost & revenue
+
+- The **flat fee** (`x_fc_maintenance_fee`) is shown in **both** the reminder email and the
+  slot‑picker page, Canadian English, `$` + tax note.
+- On booking, draft a priced line (SO/invoice) using `x_fc_maintenance_service_product_id` (or the
+  generic visit product) at the contract's fee. Payment options: **pay‑at‑door via `fusion_poynt`**
+  (existing `action_collect_payment` on the repair) or invoice after the visit.
+- Recurring revenue = one priced visit per cycle; the roll‑forward arms the next cycle automatically.
+  (Pre‑paid annual plan upsell via the existing subscription engine is out of v1 — §11.)
+
+## 9. Maintenance log & the recurring loop
+
+- The technician fills the visit via the **extended visit‑report wizard** (existing tool) — checklist
+  results, findings, parts, signature — which writes the `fusion.repair.maintenance.visit` record.
+- For `safety_critical` categories (lifts), completing the visit **issues an inspection certificate**
+  (reuse M1) and links it on the visit — the log doubles as compliance proof.
+- On task `status='completed'` → existing **roll‑forward**: `last_service_date=today`,
+  `next_due_date += interval`, reset `last_reminder_band`, **regenerate token**, visit → `done`.
+- Next cycle's reminder fires automatically when `next_due_date` re‑enters the 30‑day band.
+
+## 10. Office follow‑up crons (toggle‑gated, exist as config only today)
+- **Unbooked**: reminder sent, no booking after N days → office call activity on the contract.
+- **Overdue**: `next_due_date` passed with no completed visit in the cycle → escalation activity.
+- Driven by the existing `ir.config_parameter` toggles in `data/ir_config_parameter_data.xml`.
+- Per‑row **savepoint** isolation inside the cron loop (no `cr.commit()` in tests — CLAUDE.md #14).
+
+## 11. Out of scope (v1 — YAGNI)
+- SMS reminders / two‑way SMS booking (needs `fusion_ringcentral`).
+- Logged‑in `/my/equipment` client portal (X5).
+- Pre‑paid annual maintenance‑plan auto‑upsell at booking.
+- Full multi‑stop route optimization / batching (we use per‑tech availability + proximity ranking,
+  not a global optimizer).
+- ADP funder re‑billing of maintenance (maintenance is private‑pay flat fee in v1).
+
+## 12. Error handling & edge cases
+- **Double‑booking:** re‑validate the gap at confirm; lose the race → re‑show slots.
+- **Token:** per‑cycle regeneration; invalid/expired/already‑booked → friendly pages (exist, extend).
+- **No qualified tech / no slots:** callback fallback, not an error page.
+- **Backfill:** dry‑run + report; strict serial dedup; stagger; fallback anchor chain; never email on
+  dry‑run.
+- **Missing data:** units with no device_type/category → excluded from auto‑backfill, listed in the
+  report for manual enrollment.
+- **Audit on failure paths** (if any "booking failed" row is written in an `except`): use a separate
+  `self.env.registry.cursor()` so it survives rollback (CLAUDE.md audit rule).
+- **`message_post` HTML** bodies wrapped in `Markup()` (CLAUDE.md).
+
+## 13. Testing
+`fusion_repairs/tests/` (none exist today). Local dev is **Community** and — because we chose
+`fusion_tasks` over Enterprise `appointment` — the **entire feature is Community‑testable** on
+`odoo-modsdev`. `TransactionCase` coverage:
+- Contract spawn on `sale.order` confirm (enabled vs disabled category; quantity; idempotency).
+- Backfill wizard: **two‑regime dedup** (serial for wheelchairs; partner+product+line for lifts), accessory‑line exclusion, stagger, dry‑run produces no records, anchor fallback.
+- Booking: slot list comes from real gaps; confirm creates task+repair+visit; **double‑book guard**;
+  no‑slot fallback.
+- Roll‑forward on completion: dates advance, band reset, **token regenerated**, visit → done.
+- Crons: reminder bands; unbooked/overdue follow‑ups (savepoint isolation).
+- Run: `docker exec odoo-modsdev-app odoo -d fusion-dev --test-enable --test-tags /fusion_repairs -u fusion_repairs --stop-after-init --http-port=0 --gevent-port=0`.
+
+## 14. Deployment & configuration
+1. Land on local dev, full E2E + tests green.
+2. **Deploy `fusion_repairs` to Westin** (`odoo-westin` / `westin-v19`) — the accepted bigger lift
+   (first production deploy of fusion_repairs; verify rate‑card numbers, ACLs, asset bundles).
+3. **Configure** maintainable categories: `x_fc_maintenance_enabled`, interval, fee, skill, service
+   product — for lifts (stairlift/porch/lift chair) + power & manual wheelchairs.
+4. Ensure technicians have `x_fc_repair_skills` + start addresses (for availability/routing).
+5. Run the **backfill wizard dry‑run → review report → execute** (staggered).
+6. Watch the first reminder/booking cycle; confirm emails, slots, task creation, completion → roll.
+
+## 15. Open items to verify at implementation (rule #1 — read live source)
+- Exact representation of tech skills (`res.users.x_fc_repair_skills`) and how a category's required
+  skill maps to it (Selection vs M2O vs tag) — read fusion_repairs/fusion_tasks before modelling
+  `x_fc_maintenance_skill_id`.
+- Signatures of `_find_next_available_slot` / `_get_available_gaps` (params, return shape, working
+  hours source) and whether they already account for travel windows.
+- The visit‑report wizard's current fields/flow before extending it with the checklist.
+- The inspection‑certificate issue API (how M1 creates a certificate) for the lift link.
+- **Lift base sized** (§3.3): ~254 stairlift + ~30 porch/VPL + ~41 lift‑chair customers, but ~0 serials.
+  Still to verify: which exact products are **base units vs accessories** (so `x_fc_maintenance_enabled`
+  lands on base units only), plus the lift interval/fee per category. Lift products aren't yet tagged
+  with `fusion_repairs` categories on Westin (module not deployed there) — categorization is a deploy step.
+- `fusion_claims` device_type → maintenance‑category mapping table for the wheelchair backfill.
+
+## 16. Build sequence (for the implementation plan)
+1. **Policy + fee data model** (category fields, product override, contract extensions, constraints).
+2. **Path A trigger** (wire `_spawn_maintenance_contracts` into `action_confirm`, fee resolution, anchor fallback) + tests.
+3. **Cost in email** (add fee to the reminder template).
+4. **Technician‑aware booking** (slot‑picker page + controller on `fusion_tasks` availability; task/repair/visit creation; double‑book guard; office action; token regen) + tests — the largest unit.
+5. **Maintenance visit log + checklist** (model, per‑category seed, visit‑report‑wizard extension, inspection‑cert link) + tests.
+6. **Backfill wizard** (scan/dedup/stagger/dry‑run; fusion_claims soft bridge) + tests.
+7. **Office follow‑up crons** (unbooked/overdue) + tests.
+8. **Deploy + configure + backfill** on Westin.

docs/superpowers/specs/2026-06-02-nexacloud-odoo-billing-cutover-design.md

@@ -0,0 +1,101 @@
+# NexaCloud → Odoo Centralized Billing — Cutover (build-out · dual-run · gated flip)
+
+- **Date:** 2026-06-02
+- **Status:** Design approved — pending written-spec review
+- **Author:** Design session (Claude + Gurpreet)
+- **Parent spec:** [`2026-05-27-nexa-billing-centralized-design.md`](2026-05-27-nexa-billing-centralized-design.md) (architecture; this doc is its **phase #2** — the NexaCloud pilot)
+- **Repos:** `K:\Github\Odoo-Modules\fusion_centralize_billing` (engine) + `K:\Github\Nexa-Cloud` (the NexaCloud adapter)
+- **Hosts:** `odoo-nexa` (VM 315, Odoo 19 Enterprise, live DB `nexamain`); NexaCloud (LXC 102, app `192.168.1.250`, DB `192.168.1.50`)
+
+## 1. Goal
+
+Make Odoo (`fusion_centralize_billing` on `odoo-nexa`) the system of record for **NexaCloud** billing: build the engine pieces NexaCloud needs, import NexaCloud's active deployments as Odoo subscriptions, run Odoo in **shadow** alongside NexaCloud's existing Stripe billing for ≥1 cycle, reconcile to the cent, and then **flip** NexaCloud onto Odoo behind an explicit go/no-go gate. NexaCloud is the pilot; NexaDesk and NexaMaps follow in later increments. This does not touch Lago.
+
+## 2. Decisions locked (this session, 2026-06-02)
+
+1. **Sequence: NexaCloud first** (per parent spec), then NexaDesk, then NexaMaps.
+2. **Granularity: one Odoo subscription per NexaCloud deployment** (mirrors `nexacloud` `subscriptions.deployment_id`; the existing usage-push and `fusion.billing.reconciliation` code already key per deployment via `x_fc_nexacloud_subscription_id`).
+3. **Approach A: build → import → dual-run → gated flip**, all in this increment; the flip executes only after ≥1 green reconciliation cycle **and** explicit operator go-ahead.
+4. **Go-forward billing only.** The importer sets each subscription's `next_invoice_date` so Odoo bills only future periods. Past NexaCloud periods are **never re-issued** (this is the exact failure mode of the 2026-05-27 Lago incident — see `lago-doublecharge-incident-2026-06` memory).
+
+## 3. Current state (recon, 2026-06-02)
+
+Engine is **installed** on `nexamain` (`fusion_centralize_billing` v19.0.1.1.0; deps `sale_subscription`, `payment_stripe`, `account_accountant` installed). Runtime rows:
+
+| Table | Rows | Read |
+|---|---|---|
+| `fusion_billing_service` | 1 | only `nexacloud`; **`webhook_url` empty** |
+| `fusion_billing_account_link` | 7 | identities imported |
+| `fusion_billing_metric` | 1 | (cpu_seconds) |
+| `fusion_billing_charge` | **0** | no quota/overage pricing yet |
+| `fusion_billing_usage` | **0** | nothing ingested |
+| `fusion_billing_reconciliation` | **0** | dual-run never run |
+| `fusion_billing_webhook` | **0** | control loop never fired |
+| `sale_order` (`is_subscription`) | **0** | no subscriptions exist |
+
+Engine code status: `webhook.py` delivery engine (HMAC + backoff + dead-letter) is **complete** (its "TODO §8" header comment is stale); `usage.py` (idempotent upsert + pre-invoice rating cron + aggregation) and `reconciliation.py` (NexaCloud dual-run) are **complete**. `controllers/api.py` implements `/health`, `POST /customers`, `POST /usage`, `GET /plans`, `POST /subscriptions` only — the rest of parent-spec §7 is unimplemented (needed by NexaDesk, **not** NexaCloud).
+
+NexaCloud adapter is present but **INERT**: `config.py` `odoo_billing_enabled=False`, `odoo_billing_base_url`/`odoo_billing_api_key` empty; `usage_metering.py` pushes `cpu_seconds` only when enabled; `routers/odoo_billing.py` `/billing/webhooks/central` returns 404 when disabled; `services/odoo_billing_integration.py` is the (inert) receiver. Lago is paused (worker+clock stopped) and out of scope here.
+
+## 4. Scope
+
+### 4.1 Odoo side (`fusion_centralize_billing` + catalog data on `nexamain`)
+
+1. **Charge catalog (the main gap — currently 0).**
+   - NexaCloud plans/products → `product.template` + `sale.subscription.plan` (monthly), each tagged `plan_code` and a `product.default_code` of `NC-PLAN-<slug>` (reconciliation already filters plan lines on `default_code LIKE 'NC-PLAN-%'`).
+   - `cpu_seconds` metric (exists) → one `fusion.billing.charge` per plan: `included_quota` = the plan's bundled CPU-seconds, `price_per_unit`/`unit_batch` for overage derived from `usage_metering.HOURLY_RATES` (`cpu_per_core=$0.0075/core-hr` → per-cpu-second rate). Memory/disk are part of the flat plan today (not metered) — keep them flat unless a plan meters them.
+   - Throttle-removal fee and the CPU/RAM/disk/daily-backup **add-ons** → one-off invoice products / optional recurring add-on products tagged `NC-ADDON-<slug>`.
+   - HST: reuse native `account.tax` (13% ON); confirm the tax code matches what NexaCloud invoices apply today.
+2. **Run the importer** (`wizards/import_wizard.py`): read the `nexacloud` DB → ensure `res.partner` + `account.link` for each active customer (7 exist; backfill any missing), and create **one shadow `sale.order` (`is_subscription=True`) per active deployment**, setting `x_fc_nexacloud_subscription_id`, `x_fc_nexacloud_plan_id`, the `NC-PLAN-*` line, and **`next_invoice_date` = the deployment's next real billing date** (go-forward only). Subscriptions start in shadow (draft/not auto-charging).
+3. **Inbound API — add only what NexaCloud needs.** `POST /customers`, `POST /subscriptions`, `POST /usage`, `GET /plans` already exist. Add **subscription cancel** (`DELETE /subscriptions/:id` → terminate the `sale.order`) for NexaCloud's deprovision path. All other parent-spec §7 endpoints stay deferred to the NexaDesk increment.
+4. **Wire the control loop:** set the `nexacloud` `fusion.billing.service.webhook_url` → `https://api.vps.nexasystems.ca/api/v1/billing/webhooks/central`, and confirm `cron` schedules for `usage._cron_rate_open_periods` and `webhook._cron_dispatch` are enabled.
+
+### 4.2 NexaCloud side (`Nexa-Cloud` repo)
+
+4. **Configure + activate the adapter:** set `odoo_billing_base_url=https://erp.nexasystems.ca/api/billing/v1`, `odoo_billing_api_key=<nexacloud service key>`. Keep `odoo_billing_enabled` staged so usage push + the webhook receiver activate for shadow without yet disabling local Stripe.
+5. **Identity + subscription sync:** on deployment create / cancel, call Odoo `POST /customers` and `POST /subscriptions` / cancel (usage push already exists in `usage_metering.py`). Send a stable `external_id` (NexaCloud user id) and `subscription_external_id` (deployment/subscription id) — namespaced, to avoid the cross-app `external_id` collision noted in `nexa-billing-architecture`.
+6. **Reconciliation feed:** push NexaCloud's **actual** charged amount per (deployment, period) so `reconciliation._reconcile_rows` can diff Odoo-computed vs NexaCloud-actual. (Source: NexaCloud's own invoices/`usage_records`.)
+7. **Activate the control-loop receiver:** `routers/odoo_billing.py` `/billing/webhooks/central` → `services/odoo_billing_integration.py` maps `invoice.payment_failed`→suspend (existing `network_isolation`/`throttle_checker`/`resource_manager`), `invoice.payment_succeeded`/`subscription.reactivated`→restore, `subscription.terminated`→deprovision. Verify HMAC against the `nexacloud` service `webhook_secret`.
+
+### 4.3 Dual-run (shadow, ≥1 billing cycle)
+
+NexaCloud keeps charging via its own Stripe. Odoo computes **draft, uncharged** invoices from imported subscriptions + pushed `cpu_seconds`. `fusion.billing.reconciliation` upserts one row per `(service, deployment, period)` with `odoo_amount` vs `external_amount` and a cent-level `delta`. Operators investigate every `delta` row until a full cycle is `match` within tolerance (default $0.01).
+
+### 4.4 Gated flip (after ≥1 green cycle + explicit go)
+
+1. NexaCloud **stops its own Stripe charging** (disable the charge path in `billing_service.py` / scheduler `billing_payment` + invoice generation) and treats Odoo as SoR.
+2. Odoo subscriptions move from shadow → active; native subscription invoicing charges the **shared** Stripe account `acct_1ShlA9IkwUB1dVox` (saved cards carry over — no re-collection).
+3. Webhooks drive suspend/restore/deprovision. Past NexaCloud invoices remain archived (PDF/opening balance) — **not** re-issued.
+4. Rollback: re-enable NexaCloud local billing + set Odoo subs back to shadow (no data destroyed).
+
+## 5. Out of scope (YAGNI for this increment)
+
+- NexaDesk and NexaMaps adapters (later increments) and the inbound-API endpoints only they need (`/invoices` family, `/credit_notes`, `/catalog`, `/checkout_url`, `PUT /subscriptions` plan-change/upgrade).
+- Lago changes or decommission (Lago stays paused; its remediation is tracked separately).
+- Customer-portal redesign — use native Odoo portal as-is.
+- Metering memory/disk/bandwidth (stay flat unless a NexaCloud plan already meters them).
+
+## 6. Success criteria
+
+- A NexaCloud deployment is created as an Odoo subscription `sale.order` (`is_subscription=True`) via `POST /subscriptions`, resolving one `res.partner` through `account.link`.
+- `cpu_seconds` counters pushed to `/usage` aggregate (idempotent) into a **draft** invoice with quota → free, overage priced, HST applied — matching NexaCloud's own computed amount within $0.01.
+- A simulated `invoice.payment_failed` webhook reaches `/billing/webhooks/central` (valid HMAC) and triggers a NexaCloud suspend; `invoice.payment_succeeded` restores.
+- `fusion.billing.reconciliation` is `match` for **every** active deployment across ≥1 full cycle before any flip.
+- Re-sending the same usage counter (same `idempotency_key`) does **not** double-bill (constraint + upsert verified by test).
+- Post-flip: Odoo charges go-forward periods only; **zero** past-period re-issues.
+
+## 7. Risks & open items
+
+- **Re-billing regression (highest):** the importer MUST set `next_invoice_date` go-forward and must not finalize/charge historical periods. Add an explicit test asserting no invoice is generated for any period earlier than import time. (Direct mitigation of the 2026-05-27 Lago incident.)
+- **Odoo 19 correctness:** read live reference files from the container (`docker exec odoo-nexa-app cat …`) for `sale.order` subscription flow, `account.move`, `payment_stripe` before coding internals — never from memory (per `K:\Github\CLAUDE.md`).
+- **Idempotency:** `fusion.billing.usage` unique `(subscription, metric, idempotency_key)` already enforces it; the NexaCloud key is `nexacloud:cpu_seconds:<sub>:<period>` — keep it stable across retries.
+- **external_id namespacing:** NexaCloud must send namespaced ids so it can never collide with NexaDesk/NexaMaps in the shared Odoo identity space.
+- **Reconciliation source:** confirm where NexaCloud's "actual amount" comes from (its `invoices`/`usage_records`) and that it's net of the same HST basis Odoo uses.
+- **Flip switch safety:** disabling NexaCloud's local Stripe must be a single, reversible config flag, and the `billing_payment` scheduler job must be guarded so it can't charge once Odoo is SoR.
+- **Spec/branch target:** `Odoo-Modules` is on `feat/fusion-login-audit` with `-wt-portal`/`-wt-fm` worktrees; confirm the branch for engine changes; NexaCloud changes land on its own branch (note: pushing `Nexa-Cloud` `main` auto-deploys to prod).
+
+## 8. Test plan
+
+- Odoo unit tests (extend `fusion_centralize_billing/tests/`): catalog→charge mapping; usage aggregation + quota/overage; idempotent re-push; reconciliation match/delta; webhook HMAC sign/verify + backoff; **importer go-forward `next_invoice_date` assertion**.
+- NexaCloud tests: adapter customer/subscription calls; `/billing/webhooks/central` HMAC verify + suspend/restore/deprovision dispatch; reconciliation-amount push.
+- Dual-run acceptance: a full cycle of `match` reconciliation on real (or staged) deployments before the flip gate.

fusion_centralize_billing/models/service.py

@@ -247,3 +247,24 @@ class FusionBillingService(models.Model):
         sub.action_confirm()
         return {'status': 'ok', 'subscription_id': sub.id,
                 'subscription_state': sub.subscription_state}
+
+    def _api_cancel_subscription(self, external_ref):
+        """Cancel (close) the subscription identified by ``external_ref``.
+
+        Authorization mirrors ``_api_record_usage``: the resolved sale.order must
+        exist, be a subscription, and belong to a customer THIS service is linked
+        to. Idempotent — closing an already-churned subscription returns ok.
+        Validation (C3): an empty ref returns a 4xx-shaped error, never raises.
+        """
+        self.ensure_one()
+        if external_ref in (None, ''):
+            return {'status': 'error', 'error': 'subscription id required'}
+        sub = self._fc_resolve_subscription(external_ref)
+        linked_partners = self.account_link_ids.mapped('partner_id')
+        if not sub.exists() or not sub.is_subscription \
+                or sub.partner_id not in linked_partners:
+            return {'status': 'error', 'error': 'unknown subscription'}
+        if sub.subscription_state != '6_churn':
+            sub.set_close()
+        return {'status': 'ok', 'subscription_id': sub.id,
+                'subscription_state': sub.subscription_state}

fusion_centralize_billing/tests/__init__.py

@@ -6,3 +6,4 @@ from . import test_webhook
 from . import test_importer
 from . import test_reconciliation
 from . import test_invoice_ledger
+from . import test_subscription_cancel

fusion_centralize_billing/tests/test_invoice_ledger.py

@@ -18,11 +18,26 @@ def _inv_fixture():
     }]
 
 
+def _fc_ensure_ca_billing_env(env):
+    """Prod (`nexamain`) is a fully-configured Canadian company; a bare test DB is not.
+    Give it the two things the ledger needs: an active CAD currency and a 13% sale tax
+    matching invoice.ledger.wizard._fc_tax_for (type_tax_use=sale, percent, amount=13)."""
+    cad = env.ref('base.CAD')
+    if not cad.active:
+        cad.sudo().write({'active': True})
+    Tax = env['account.tax'].sudo()
+    if not Tax.search([('type_tax_use', '=', 'sale'),
+                       ('amount_type', '=', 'percent'), ('amount', '=', 13.0)], limit=1):
+        Tax.create({'name': 'HST 13%', 'type_tax_use': 'sale',
+                    'amount_type': 'percent', 'amount': 13.0})
+
+
 @tagged('post_install', '-at_install')
 class TestLedgerFamily(TransactionCase):
 
     def setUp(self):
         super().setUp()
+        _fc_ensure_ca_billing_env(self.env)
         self.W = self.env['fusion.billing.invoice.ledger.wizard'].sudo()
 
     def test_family_classification(self):
@@ -47,6 +62,7 @@ class TestLedgerTax(TransactionCase):
 
     def setUp(self):
         super().setUp()
+        _fc_ensure_ca_billing_env(self.env)
         self.W = self.env['fusion.billing.invoice.ledger.wizard'].sudo()
 
     def test_tax_for_13pct_is_a_13_percent_sale_tax(self):
@@ -68,6 +84,7 @@ class TestLedgerIngest(TransactionCase):
 
     def setUp(self):
         super().setUp()
+        _fc_ensure_ca_billing_env(self.env)
         self.W = self.env['fusion.billing.invoice.ledger.wizard'].sudo()
         self.Move = self.env['account.move']
 
@@ -174,6 +191,7 @@ class TestLedgerVerifiedSync(TransactionCase):
 
     def setUp(self):
         super().setUp()
+        _fc_ensure_ca_billing_env(self.env)
         self.W = self.env['fusion.billing.invoice.ledger.wizard'].sudo()
         self.Move = self.env['account.move']
         ICP = self.env['ir.config_parameter'].sudo()

fusion_centralize_billing/tests/test_subscription_cancel.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install')
+class TestSubscriptionCancel(TransactionCase):
+
+    def _service(self, code, name):
+        Svc = self.env['fusion.billing.service'].sudo()
+        return Svc.search([('code', '=', code)], limit=1) or Svc.create(
+            {'name': name, 'code': code})
+
+    def setUp(self):
+        super().setUp()
+        self.plan = self.env['sale.subscription.plan'].sudo().create(
+            {'name': 'Monthly', 'billing_period_value': 1, 'billing_period_unit': 'month'})
+        self.product = self.env['product.product'].sudo().create(
+            {'name': 'NexaCloud Plan', 'type': 'service',
+             'recurring_invoice': True, 'list_price': 49.0})
+        self.svc_a = self._service('nexacloud', 'NexaCloud')
+        self.svc_b = self._service('other_app', 'Other App')
+        self.svc_a._api_upsert_customer({'external_id': 'user-1', 'name': 'Acme'})
+        res = self.svc_a._api_create_subscription({
+            'external_customer_id': 'user-1', 'plan_id': self.plan.id,
+            'lines': [{'product_id': self.product.id, 'quantity': 1}]})
+        self.sub = self.env['sale.order'].browse(res['subscription_id'])
+
+    def test_cancel_closes_subscription(self):
+        self.assertEqual(self.sub.subscription_state, '3_progress')
+        res = self.svc_a._api_cancel_subscription(str(self.sub.id))
+        self.assertEqual(res['status'], 'ok')
+        self.assertEqual(self.sub.subscription_state, '6_churn')
+
+    def test_cancel_is_idempotent(self):
+        self.svc_a._api_cancel_subscription(str(self.sub.id))
+        res = self.svc_a._api_cancel_subscription(str(self.sub.id))
+        self.assertEqual(res['status'], 'ok')
+        self.assertEqual(self.sub.subscription_state, '6_churn')
+
+    def test_cancel_unknown_subscription_rejected(self):
+        res = self.svc_a._api_cancel_subscription('999999999')
+        self.assertEqual(res['status'], 'error')
+        self.assertEqual(res['error'], 'unknown subscription')
+
+    def test_cancel_cross_service_rejected(self):
+        # svc_b is not linked to the customer that owns self.sub
+        res = self.svc_b._api_cancel_subscription(str(self.sub.id))
+        self.assertEqual(res['status'], 'error')
+        self.assertEqual(res['error'], 'unknown subscription')
+        self.assertEqual(self.sub.subscription_state, '3_progress')
+
+    def test_cancel_missing_id_rejected(self):
+        res = self.svc_a._api_cancel_subscription('')
+        self.assertEqual(res['status'], 'error')

fusion_centralize_billing/tests/test_usage.py

@@ -9,7 +9,8 @@ class TestRatingCron(TransactionCase):
 
     def setUp(self):
         super().setUp()
-        self.metric = self.env['fusion.billing.metric'].sudo().create(
+        Metric = self.env['fusion.billing.metric'].sudo()
+        self.metric = Metric.search([('code', '=', 'cpu_seconds')], limit=1) or Metric.create(
             {'name': 'CPU seconds', 'code': 'cpu_seconds', 'aggregation': 'sum'})
         self.plan_a = self.env['sale.subscription.plan'].sudo().create(
             {'name': 'Plan A', 'billing_period_value': 1, 'billing_period_unit': 'month'})
@@ -67,7 +68,8 @@ class TestUsageIngestion(TransactionCase):
 
     def setUp(self):
         super().setUp()
-        self.metric = self.env['fusion.billing.metric'].sudo().create(
+        Metric = self.env['fusion.billing.metric'].sudo()
+        self.metric = Metric.search([('code', '=', 'cpu_seconds')], limit=1) or Metric.create(
             {'name': 'CPU seconds', 'code': 'cpu_seconds', 'aggregation': 'sum'})
         self.plan = self.env['sale.subscription.plan'].sudo().create(
             {'name': 'Monthly', 'billing_period_value': 1, 'billing_period_unit': 'month'})

fusion_centralize_billing/tests/test_webhook.py

@@ -13,11 +13,17 @@ class TestWebhookEngine(TransactionCase):
 
     def setUp(self):
         super().setUp()
-        self.service = self.env['fusion.billing.service'].sudo().create({
+        Service = self.env['fusion.billing.service'].sudo()
+        vals = {
             'name': 'NexaCloud', 'code': 'nexacloud',
             'webhook_url': 'https://api.vps.nexasystems.ca/billing/webhook',
             'webhook_secret': 'whsec_test',
-        })
+        }
+        self.service = Service.search([('code', '=', 'nexacloud')], limit=1)
+        if self.service:
+            self.service.write(vals)
+        else:
+            self.service = Service.create(vals)
         self.Webhook = self.env['fusion.billing.webhook'].sudo()
 
     def test_enqueue_signs_payload(self):

fusion_plating/CLAUDE.md

@@ -630,8 +630,27 @@ De-Racking → Final inspection → Shipping`
 Columns are first-class — they always render in this exact order, never
 reorder, never collapse when empty. Driven by `fp.work.centre.area_kind`
 Selection (added 2026-05-23). Each `fp.job.step.area_kind` is computed
-(stored) from `work_centre.area_kind` with a fallback to a step-kind
-dispatch table (`_STEP_KIND_TO_AREA` in `fusion_plating_jobs/models/fp_job_step.py`).
+(stored) in `_compute_area_kind` (`fusion_plating_jobs/models/fp_job_step.py`):
+`work_centre.area_kind` → else `recipe_node.kind_id.area_kind` (the
+`fp.step.kind` taxonomy is authoritative; the legacy `_STEP_KIND_TO_AREA`
+dict is gone) → else catch-all `'plating'`.
+
+**Gating/"Ready for X" marker steps fall FORWARD (fixed 2026-06-02).** The
+`fp.step.kind` named *Gating* has `code='gating'` **and `area_kind='receiving'`**.
+A gating step is a non-physical "ready for the next stage" marker, so
+mapping it to Receiving made a *mid-recipe* gate snap the job's card back
+to the first column (Racking → "Ready for processing" jumped to Receiving,
+so the job looked like it vanished). `_compute_area_kind` therefore detects
+a gating step via the **stable `kind_id.code == 'gating'`** (never the
+display name) and resolves its column to the **next non-gating step's** raw
+area (so "Ready for processing" before plating shows in the **Plating**
+column); if nothing real follows, it falls back to the last real stage.
+Helpers: `_fp_is_gating_step`, `_fp_raw_area_kind` (own work_centre/kind
+only — no look-ahead, avoids recursion), `_fp_resolve_area_kind`. **NB:**
+`area_kind` is a STORED compute, so after changing this logic you must
+force-recompute existing rows (`env['fp.job.step'].search([])._compute_area_kind()`
++ `flush_recordset(['area_kind'])` + commit) — a `-u`/restart alone leaves
+old values stale.
 
 **Spec D3:** all wet-line steps (Soak Clean, Electroclean, Acid Dip,
 Etch, Desmut, Zincate, Rinse, E-Nickel, Chrome, Anodize, Black Oxide,
@@ -1832,3 +1851,57 @@ When adding a new admin config, drop it into the right Configuration folder:
 - Generic value lists → Reference Data
 
 Don't add new top-level Configuration entries (siblings of the 7 folders) unless absolutely necessary — Settings is the only one allowed.
+
+---
+
+## Partial Order Handling — parts fanning across stages (shipped 2026-06-02)
+
+A 50-part job can have parts at several stages at once (10 Masking, 20 Plating, 20 Baking). The data layer always supported this (`fp.job.step.qty_at_step` = live parked count, computed from `fp.job.step.move` rows); 2026-06-02 made it **visible and operable**. Spec: [`docs/superpowers/specs/2026-06-02-shopfloor-partial-order-handling-design.md`](docs/superpowers/specs/2026-06-02-shopfloor-partial-order-handling-design.md). Versions: `fusion_plating 19.0.22.2.0`, `fusion_plating_jobs 19.0.11.6.0`, `fusion_plating_shopfloor 19.0.36.2.0`. Tracking model = **fluid quantities per stage** for normal flow + existing hold/scrap/rework records for exceptions (no new model, no migration). Close behaviour = **wait to reconverge** (the lifecycle is unchanged; the diverged subset keeps the job open via the existing `qty_done + qty_scrapped == qty` gate).
+
+**Durable gotchas (non-obvious):**
+
+1. **The plant kanban emits one card PER (job, stage), keyed by a composite `"{job_id}:{area}"`** — NOT one card per job. `cards` is a dict of composite-key → presence payload; a split job lists its key in several `columns[].card_ids`. See `_job_presences` / `_render_presence` in `plant_kanban.py`. A job with all parts at one stage yields exactly ONE presence (identical to the old board). The PRIMARY presence (active-step column) keeps the full job-level `card_state`; SECONDARY presences derive a simpler state from their own focus step (`_secondary_card_state`). Anything reading the board payload must handle composite keys + multi-column jobs. **A presence is emitted ONLY where parts physically are (`qty_at_step > 0`, incl. the first-active seed) OR a step is `in_progress`/`paused` — NEVER for a merely `ready`/`pending` future step.** These recipes seed EVERY downstream step to `ready` at job creation (not `pending`), so keying presence off `ready` made one job show in every not-yet-started stage at once (WO-30061 bug, fixed 2026-06-02). The old single-card board masked this because `active_step_id` picked just one. Strict sequential progress falls out for free: the `qty_at_step` seed always sits on the lowest-sequence non-terminal step and advances as each completes — so don't add `ready` back to the presence condition.
+
+2. **`fp.job.step` has NO `qty_done` / `qty_scrapped` fields.** Those live on `fp.job`. The Move controller previously read `from_step.qty_done - from_step.qty_scrapped` for "available to move" → always 0 → the partial-move path was effectively dead. The source of truth for "parts parked here" is **`qty_at_step`** (move preview/commit + rack moves all read it now). Never reintroduce `step.qty_done`.
+
+3. **The Move Parts dialog was only wired into the DEPRECATED `shopfloor_tablet.js`** — the live `fp_job_workspace` had no move/advance action, so operators literally could not move partial parts. The "Send → <next>" action now lives in `job_workspace.js` (`getStepActions` advance descriptor → `onAdvanceStep` → `FpMovePartsDialog`). The dialog itself was slimmed (qty steppers, no keyboard; Transfer Type + To Location collapsed behind "More options"). If you add another operator surface, wire the advance action there too.
+
+4. **Partial-flow "light up" lives in `move_controller._do_move_parts_commit` / `_do_move_rack_commit`:** a forward (`transfer_type='step'`) move (a) flips the destination step `pending → ready` so the receiving operator gets an actionable card with no action by anyone, and (b) calls `from_step._fp_try_autofinish_on_drain()` (best-effort, swallows finish-gate UserErrors). It does **not** auto-START the destination — `button_start` stays explicit to keep the labour timer accurate (S16). No auto-ready/auto-finish for hold/scrap/rework moves. **Two non-obvious traps in `_fp_try_autofinish_on_drain` (both fixed 2026-06-02):** (1) it must guard on a real **OUTGOING** move (`move_ids` to a different step, `qty_moved > 0`), NOT `_fp_has_real_incoming()` — the FIRST/seeded stage (e.g. Racking) is fed by the `qty_at_step` seed, has no incoming move, and so never auto-finished when all its parts were sent forward. (2) It is **best-effort and gated**: `button_finish` still runs the required-step-input / sign-off / contract-review gates, so a step with an unrecorded required input (e.g. Racking's "Count the Parts") will NOT auto-finish on drain — it stays `in_progress` with `qty_at_step=0` ("running, 0 here → finish me") until the operator records the input and finishes. That's correct (can't complete a step missing compliance data); don't try to force auto-finish past the gates.
+
+5. **The predecessor gate is qty-aware: `_fp_should_block_predecessors()` returns False once `_fp_has_real_incoming()` is true** (an incoming move from a different step with `qty_moved > 0`). A step with parts physically parked at it is startable regardless of whether upstream steps are fully done. This is the single source of truth shared by `can_start`, `_compute_blocker`, `button_start`, and the Move dialog's `_blockers_for_move`. **Don't "fix" the predecessor gate back to pure sequence-based** — it would re-lock the next stage while the rest of the batch is still upstream. **Second, distinct trap (fixed 2026-06-02): the Move dialog's `_blockers_for_move` predecessor check must only flag unfinished steps STRICTLY BETWEEN `from_step` and `to_step` (`from_step.sequence < s.sequence < to_step.sequence`), NOT all steps before `to_step`.** The original `s.sequence < to_step.sequence` filter counted the `from_step` itself (which is in-progress *by definition* when you advance partial parts out of it) as an "unfinished predecessor" of the destination — so EVERY partial advance to a not-yet-started next step showed a hard "Predecessor not done: \<from_step\>" blocker and greyed out SEND (hit on WO-30061). The between-only rule allows the immediate-next advance, still blocks skip-ahead moves over incomplete intermediate stages, and leaves backward (rework) moves unblocked (empty range).
+
+6. **Move-based scrap (`transfer_type='scrap'`) does NOT touch `job.qty_scrapped`.** At close, `button_mark_done` calls `_fp_scrapped_via_moves()` and folds it into `qty_scrapped`, then auto-fills `qty_done = qty − qty_scrapped` (was: blindly `= job.qty`, which over-counted when parts were scrapped). The reconciliation gate is still the safety net.
+
+**Verification:** the plating modules can't be installed on the local Community dev DB (missing enterprise deps — same reason `fusion_plating` shows `installed=0` in `modsdev`/`fusion-dev`). Static checks done: pyflakes (Python), lxml parse (XML), `node --check` as `.mjs` (JS — `node --check` on a `.js` errors with "Cannot use import statement outside a module"; copy to `/tmp/x.mjs` first). Dynamic tests + browser check require an installed env (entech / odoo-trial).
+
+### Rollout fixes + open items (live operator testing, 2026-06-02)
+
+Bugs that only real tablet testing surfaced (all fixed, deployed to entech, on main):
+- **Phantom future-stage cards** — a job showed in every not-yet-started `ready` stage. Presence keys off parked qty / `in_progress`, never `ready` (gotcha 1).
+- **Scan buttons** — camera button rendered two icons; "Scan Code" vs "Camera" was confusing. `QrScanner` keeps its single icon; now **"Scan QR"** (camera) + **"Enter Code"** (wedge/manual). Don't pass an emoji in the `QrScanner` label — it doubles the icon.
+- **Dark-mode invisible text** — `var(--bs-body-color)` / `var(--bs-secondary-color)` are UNDEFINED in Odoo's backend CSS → always fall back to the dark hex. Use inherit / translucent `rgba()` (see the Dark-mode SCSS section).
+- **Partial advance blocked by the from-step's own predecessor** — `_blockers_for_move` now blocks only steps STRICTLY BETWEEN from/to (gotcha 5).
+- **First/seeded stage never auto-finished on drain** — `_fp_try_autofinish_on_drain` guards on a real OUTGOING move, not incoming.
+- **Gating "Ready for X" steps zig-zagged the card back to Receiving** — gating steps fall FORWARD to the next real stage's column (see the Plant-View `area_kind` note).
+
+Open / deferred (next session):
+- **Discoverability (not built):** show a "N here" qty badge on step rows + the count on the Send button; add a "✓ all sent — record inputs to finish" hint when a step is drained-to-0 but still has a pending required input (answers operators' "why is it still active?").
+- **Scrap / Rework as standalone intent buttons** — currently under the Move dialog's "More options"; only Hold has its own button.
+- **Automated tests NOT written** — modules need enterprise deps (can't install on local Community); validated via pyflakes/lxml + live odoo-shell verification on entech. A `bt_s*`-style battle test is the recommended next step.
+- **Plant-card status chips** read fine but bright in dark mode (deferred).
+
+---
+
+## Dark-mode SCSS gotchas — shop-floor dialogs/components (fixed 2026-06-02)
+
+Operators reported invisible (dark-on-dark) text in the workspace + "Cannot Finish Step" dialog under Odoo dark mode. Root causes + the rules:
+
+1. **Odoo's compiled backend CSS does NOT define the Bootstrap colour custom-properties — `var(--bs-body-color)`, `var(--bs-secondary-color)`, `var(--bs-tertiary-bg)`, `var(--bs-body-bg)` are REFERENCED but never DEFINED (verified 2026-06-02: 0 definitions for `--bs-body-color`/`--bs-secondary-color` in the live `web.assets_backend` text).** So **any `color: var(--bs-body-color, #hex)` resolves to the `#hex` fallback in BOTH light and dark mode** — a dark hex → invisible on a dark surface. (`var(--text-secondary, …)` is even worse — that var name is entirely made-up.) Odoo themes the backend via **runtime `[data-bs-theme="dark"]`** (Bootstrap 5.3) + SCSS literals, NOT via those CSS vars, and NOT via `prefers-color-scheme`. Do NOT colour custom text with `var(--bs-*)`. **Correct, verified options:**
+   - **Inherit** — omit `color:` entirely so the element takes the dialog/page theme colour. Proven: the finish-block dialog's title + `.o_fp_finish_block_list` items have no colour and ARE readable in both modes; the `.o_fp_finish_block_msg` line was the ONLY broken one because it set `color: var(--bs-body-color,…)`. Removing that one line fixed it. This is the simplest fix for dialog/modal text.
+   - **Translucent `rgba()` for tinted boxes** — e.g. `background: rgba(245,158,11,0.16)` (warning) / `rgba(128,128,128,0.12)` (neutral). Works over whatever the live theme background is. (`color-mix(…, var(--bs-body-bg))` does NOT work — `--bs-body-bg` is undefined, so the whole `color-mix` is invalid and dropped.)
+   - **Explicit `[data-bs-theme="dark"] .my-class { color: … }`** override with literal hex when you genuinely need a different value per theme.
+   - **Compile-time `$o-webclient-color-scheme == dark`** literals only work if the **dark bundle is actually served**; on entech the active mechanism is runtime `[data-bs-theme]`, so prefer inherit / rgba / `[data-bs-theme=dark]` selectors over the two-bundle approach for backend dialogs.
+
+   NOTE: ~33 muted-text usages across `job_workspace.scss` + 5 component stylesheets still use `var(--bs-secondary-color, #hex)` (undefined → dark hex). They're muted/secondary so less glaring, but technically wrong in dark mode — sweep them to one of the patterns above when touched.
+2. **Odoo's bootstrap does NOT define the Bootstrap 5.3 `--bs-{color}-bg-subtle` / `--bs-{color}-text-emphasis` family.** Verified by grepping `web/static/lib/bootstrap/scss/_root.scss`: `--bs-tertiary-bg` and `--bs-secondary-color` exist; `--bs-warning-bg-subtle`, `--bs-danger-bg-subtle`, `--bs-warning-text-emphasis` are MISSING. So `var(--bs-warning-bg-subtle, #fef3c7)` just yields the bright hex fallback — useless for dark mode. **For tinted status banners (warning/danger/info), use `color-mix` over the live theme bg instead:** `background-color: color-mix(in srgb, #f59e0b 14%, var(--bs-body-bg)); color: var(--bs-body-color);` — pale in light mode, dark-tinted in dark mode, readable in both, graceful-degrades to no-bg on ancient browsers. (`color-mix` works in `background-color` per the rule-8 note; keep it out of shorthands.) Solid accent elements (selected pills, priority dots) with `color: white` are fine as-is in both modes.
+3. **Confirmed-present, dark-aware Odoo vars to reach for:** `--bs-body-color` (primary text), `--bs-secondary-color` (muted text), `--bs-body-bg` / `--bs-tertiary-bg` (surfaces), `--bs-border-color`. The deliberate color-coded plant-card status chips (`_plant_card.scss` `.kind-*` / `.tag-*`) are light-bg + dark-text (readable in both modes, just bright on a dark card) — intentionally left as a color-coded set.

fusion_plating/docs/superpowers/specs/2026-06-02-shopfloor-partial-order-handling-design.md

@@ -0,0 +1,173 @@
+# Shop Floor — Partial Order Handling (design)
+
+- **Date:** 2026-06-02
+- **Status:** Approved (design), pending implementation plan
+- **Modules touched:** `fusion_plating_shopfloor`, `fusion_plating_jobs`, `fusion_plating` (core step model)
+- **Author context:** Nexa Systems / EN Technologies (entech), Odoo 19
+
+## Problem
+
+A plating job runs 50 parts, but parts physically fan out across stages — 10 at Masking, 20 at Plating, 20 at Baking — because the shop processes in racks/waves through tank-limited stations. Today the Shop Floor board collapses each job to **one card in one column** (the single `active_step_id.area_kind`), so an operator standing at Baking has no way to see "10 of this job's parts are here, waiting for me." Operators need to handle the spread-out parts through the different stages, and it must be **easy** (minimal typing, minimal guessing) and **production-ready**.
+
+## Goals
+
+- Operators can **see** a job's parts at every stage where they physically are.
+- Operators can **advance** a subset to the next stage with near-zero friction.
+- Failed/held/rework subsets are tracked and visible (not silently lost).
+- The change is **additive** — it must not redesign the board, the quantity model, the workspace entry contract, or the close/cert/ship/invoice lifecycle.
+
+## Non-goals (explicitly out of scope for v1)
+
+- **Partial shipping** — shipping the good parts now and the rest later (split CoCs, split deliveries, partial invoicing). The job reconverges and ships once.
+- **Named sub-lots** — persistent per-group identity/labels for interchangeable parts.
+- **Manager-initiated job split** — closing a job at a shipped quantity and spawning a follow-on job for the remainder. Notable as a possible future add-on; operators never touch it.
+- Multi-cert / multi-delivery per job; per-delivery quantity tracking.
+
+---
+
+## Current-state baseline (verified in code)
+
+**The data layer already supports partial quantities.**
+- `fp.job.step.qty_at_step` — live "parts parked here" = `sum(incoming moves) − sum(outgoing moves)`, with a first-step seed (the earliest non-terminal step implicitly holds full `job.qty` before any move). Compute at `fusion_plating/models/fp_job_step.py::_compute_qty_at_step`.
+- `fp.job.step.move` (`fusion_plating/models/fp_job_step_move.py`) — chain-of-custody row per move; `qty_moved` already lets an operator move a subset; `transfer_type` ∈ {step, hold, scrap, rework, split, return}.
+- `move_parts_commit` (`fusion_plating_shopfloor/controllers/move_controller.py`) already moves a subset and advances `qty_at_step_start/finish`.
+- `button_finish` already refuses to close a stage while parts are parked there with a downstream step waiting (`fusion_plating/models/fp_job_step.py`).
+
+**The gap is visibility + interaction.**
+- `fp.job.active_step_id` picks **one** step by priority (in_progress > paused > ready > pending) — `fusion_plating_jobs/models/fp_job.py::_compute_active_step_id`.
+- The plant kanban places the whole job in the **one** column of that step — `fusion_plating_shopfloor/controllers/plant_kanban.py::_resolve_card_area` / `_render_card`; the board payload is `cards` (dict keyed by `str(job.id)`) + `columns[].card_ids` (list of job ids); OWL renders one `FpPlantCard` per id (`plant_kanban.xml`, `components/plant_card.js`).
+- The Move dialog (`move_parts_dialog.{js,xml}`) exposes Transfer Type (6 options) and To Location (6 options) as always-visible dropdowns and uses a raw numeric input for qty.
+
+**The close lifecycle assumes one job = one quantity = one CoC = one delivery.**
+- `button_mark_done` (`fusion_plating_jobs/models/fp_job.py`) gates on step-completion, bake, `qty_done + qty_scrapped == qty`, receiving reconciliation, and QC, then calls `_fp_create_delivery()` + `_fp_create_certificates()` (one each).
+- Auto-advance: last step finished → `awaiting_cert` (if a cert is required) or `awaiting_ship`; cert issue advances `awaiting_cert → awaiting_ship`; cert void regresses. There is an order-level "ship together" constraint (`_fp_order_ship_state`).
+- No partial-shipment infrastructure exists anywhere.
+
+---
+
+## Decisions
+
+| Fork | Decision |
+|---|---|
+| Tracking model | **C — fluid quantities per stage + existing records for exceptions.** Normal flow uses `qty_at_step`; failed/held/rework subsets ride the existing hold/scrap/rework records. No new core model. |
+| Board representation | **Option 2 — a card per stage-presence.** A job appears as a card in every stage where it has parts; composite `job:area` card keys. Unsplit jobs render identically to today. |
+| Operator move interaction | **Easy-advance.** One intent-named "Send to [next] →" action with everything defaulted; steppers / rack-tap instead of a keyboard; Hold/Scrap/Rework as distinct buttons. |
+| Downstream "light-up" | **Auto-ready on arrival + qty-aware predecessor gate + auto-finish source on drain.** No auto-start (labour accuracy). |
+| Close behaviour | **Option B — wait to reconverge.** The close/cert/ship/invoice lifecycle is unchanged; the diverged subset keeps the job open via the existing reconciliation gate. |
+
+---
+
+## Detailed design
+
+### A. Data model
+
+No new model and no new core fields are required. The feature reuses:
+- `fp.job.step.qty_at_step` (live parked count) — already the source of truth.
+- `fp.job.step.move` + `transfer_type` — already records advance/hold/scrap/rework.
+- `fusion.plating.quality.hold` — already represents "N parts of this job are held" (the tracked exception group).
+
+### B. Board — card per stage-presence
+
+**Backend (`plant_kanban.py`).** Replace the "one area per job" bucketing with per-stage presences. For each in-flight job:
+
+1. Group the job's **non-terminal** steps by `area_kind` (note: many steps can share an area, e.g. all wet-line steps roll into `plating` per the existing column map).
+2. For each area, compute:
+   - `qty_here` = sum of `qty_at_step` across that area's non-terminal steps.
+   - `focus_step_id` = the most-actionable step in the area (in_progress > paused > ready > pending) — used for the tap target and the per-presence state.
+3. **Emit a presence** for an area when `qty_here > 0` **or** any step in the area is in_progress/paused/ready (a started-but-drained stage still shows until finished).
+4. **Exception presences:** a quality hold on N parts surfaces as a flagged presence ("🔴 N on hold") in the stage it is associated with. *Linkage detail* (hold→step/area vs. hold→job + area inference) is finalized in the plan after reading the hold model; fallback is to attach the held indicator to the job's furthest-along presence. Rework re-entering an earlier stage shows as a normal presence there (optionally flagged "rework"). Scrap is not a presence (counted in `qty_scrapped`, shown in job totals only).
+
+**Payload schema.** `cards` becomes a dict keyed by composite `"{job_id}:{area}"`; `columns[].card_ids` lists composite keys; a split job lists one key in each occupied column. Each presence payload is the existing card payload **plus**: `area_kind`, `qty_here`, `job_qty`, `focus_step_id`, and a per-presence `card_state` / `state_chip` / `operator` / `step_name` derived from that area's focus step (not the job's global `active_step_id`). Reuse the existing helpers (`_state_chip`, `_compute_tags`, `_due_label`, `_icons`).
+
+- The job-level `card_state` / `active_step_id` computes stay **unchanged** — they still drive server-side filters and KPI counts.
+- **KPIs** dedupe by `job_id` (count distinct jobs, not presences).
+- **mini_timeline** on every presence still shows the **whole-job** spread, so the big picture is visible from any stage.
+
+**Frontend (`plant_kanban.xml`, `components/plant_card.js`).**
+- The render loop (`t-foreach columns → card_ids → FpPlantCard`) is **unchanged** — `t-key="card_id"` already works with composite keys.
+- `FpPlantCard` gains a "**{qty_here} of {job_qty}**" line; `onCardClick` passes `focus_step_id` into the workspace (the workspace already accepts `focus_step_id` — see the FP-STEP scan path in `plant_kanban.js`).
+- `filteredCardIds` is unchanged (it filters on card payload fields; each presence carries the same searchable fields, so all presences of a matching job show).
+
+**Unsplit invariant.** A job with all parts at one stage produces exactly one presence → one card in one column → byte-for-byte identical to today. Multi-card behaviour only activates on an actual split.
+
+### C. Operator flow — easy advance
+
+**Primary action: "Send to [next stage] →".** Surfaced on the stage presence (card/workspace). Opens a slim confirm pre-set to:
+- `to_step` = next step in recipe sequence (no guessing).
+- `qty` = all parked here (`qty_at_step`); adjustable with **± steppers + an "All" preset** — the keyboard never opens for the common case.
+- `transfer_type` = `step` (hidden); `to_location` = `global` (hidden behind **More options**); `to_tank` = recipe default (existing behaviour).
+- Compliance prompts render only when the recipe author marked them (unchanged), using pickers, not free text.
+
+**Racked parts:** when parts are on racks, advancing is **rack-granular** — tap the rack(s) to send, moving that rack's count atomically via the existing **Move Rack** flow. No quantity typed at all.
+
+**Exceptions get their own intent-named buttons** (replacing the Transfer Type dropdown for everyday use):
+- **Hold** — pick qty + reason from a picker → reuses the existing hold composer → the subset becomes the tracked held group; the rest stay put.
+- **Scrap** — qty + reason → counted in `qty_scrapped`.
+- **Rework** — qty + destination earlier stage → a `transfer_type='rework'` move.
+
+The full generic Move dialog remains available behind "More options" — we slim the default path, we don't delete capability.
+
+### D. State machine — the invisible "light-up"
+
+Three small, additive behaviours so operators never manage stage state manually:
+
+1. **Auto-ready on arrival.** In `_do_move_parts_commit` (and `_do_move_rack_commit`): after the move + counter advance, if `to_step.state == 'pending'`, set it to `ready`. Never downgrade a step. Result: the receiving operator's column immediately shows a "{qty} of {job_qty} · Ready to start" card with no action by anyone.
+2. **Qty-aware predecessor gate.** A step that has **real parts parked** (an incoming move with `from_step_id != step` and `qty_moved > 0`) is startable regardless of whether upstream steps are fully done. Applied consistently in `_fp_should_block_predecessors` (used by both `button_start` and the Move dialog's `_blockers_for_move`). Rationale: once parts physically arrive, the predecessor lock is moot.
+3. **Auto-finish the source on drain-to-zero.** When a move drains `from_step.qty_at_step` to 0 and the step is in_progress with no remaining work, finish it via the existing finish path (generalize the `action_complete_one_to_next` drain→finish pattern to bulk moves). One fewer tap.
+
+Deliberately **no auto-start** of the receiving step — `button_start` stays an explicit tap because it begins the labour timer (keeps cost/time accurate and avoids the phantom-timer problem the S16 cron already fights).
+
+**Correctness fix.** The move preview currently derives availability from `from_step.qty_done − from_step.qty_scrapped`; change it to read `qty_at_step` (the live parked count shown on the card) so the pre-filled number **always matches what the operator sees**.
+
+### E. Close — wait to reconverge (Option B)
+
+The close/cert/ship/invoice lifecycle is **unchanged**:
+- `button_mark_done` gates, `_fp_create_certificates` (one CoC), `_fp_create_delivery` (one delivery), and the `awaiting_cert`/`awaiting_ship` transitions stay as-is.
+- The diverged subset keeps the job open **for free**: with parts in hold/rework, `qty_done + qty_scrapped` cannot equal `qty`, so the existing reconciliation gate simply won't let the job close until those parts resolve (reworked → done, or scrapped → counted). This is the correct behaviour, already enforced.
+- Normal jobs reconverge at Final Inspection (all parts back in one count) and close once.
+
+**Hardening (additive).** At close, `qty_done` auto-fill should derive from the quantity that actually **completed the final runnable step** (via the last step's `qty_at_step_finish` / move chain), not assume `job.qty`. Keep the existing reconciliation gate — just feed it an honest number when parts fanned out.
+
+### F. Reconciliation invariant
+
+At any time: `job.qty = (parts parked across all stages) + (on hold) + (in rework) + (scrapped) + (completed/shipped)`. The board surfaces the first three as presences; `qty_scrapped` and the final count feed the existing close gate `qty_done + qty_scrapped == qty`.
+
+---
+
+## Blast radius
+
+**Changes**
+- `plant_kanban.py` — per-stage presence rendering + composite keys + KPI dedupe (localized to `_render_card` + the bucketing loop; reuses all existing chip/tag/icon helpers).
+- `components/plant_card.js` + `plant_kanban.xml` — "{qty} of {job_qty}" line; tap passes `focus_step_id` (~a few lines).
+- `move_parts_dialog.{js,xml}` — slim "Advance" default (steppers, "All", hidden advanced fields); Hold/Scrap/Rework intent buttons; full dialog behind "More options".
+- `move_controller.py` — auto-ready on arrival; auto-finish on drain; preview availability/pre-fill from `qty_at_step`.
+- `fp_job_step.py` — qty-aware predecessor gate; bulk drain→finish helper.
+- `fp_job.py` — `qty_done` derivation at close (hardening only).
+
+**Does NOT change**
+- The quantity model (`qty_at_step`, `fp.job.step.move`).
+- The OWL component tree (FpTabletLock → header → board → columns → FpPlantCard → FpMiniTimeline), polling, filters, search, station pairing, QR.
+- The Job Workspace entry contract (`focus_step_id` already supported).
+- Holds / certs / bake windows / QC.
+- The close → cert → ship → invoice lifecycle (`button_mark_done`, `_fp_create_certificates`, `_fp_create_delivery`, awaiting_cert/awaiting_ship, order "ship together").
+
+---
+
+## Edge cases
+
+- **No recipe / no steps:** orphan fallback unchanged (Receiving column).
+- **Multiple steps in one area** (wet-line → plating): presence aggregates `qty_here` across them; `focus_step_id` is the most-actionable.
+- **First-step seed:** before any move, the whole qty sits at the first stage → one presence = today's single card.
+- **Recombination:** 30 + 20 both reaching Baking simply read as `qty_here = 50` at that stage (fluid quantities merge automatically).
+- **Held parts with no step linkage:** held indicator attaches to the job's furthest-along presence (plan-time detail).
+- **Search match:** every presence of a matching job shows across its columns (each carries the same searchable fields).
+
+## Testing
+
+- **Unit:** `qty_at_step` across a multi-stage split; qty-aware predecessor (parts-present → startable); auto-ready pending→ready on move; auto-finish source on drain-to-zero; `qty_done` derivation at close; reconciliation gate still fires with held parts.
+- **Integration:** board emits N presences for a split job and exactly 1 for an unsplit job; KPIs dedupe by job; tapping a presence opens the workspace on the right step.
+- **Persona walk:** operator finishes a subset at Plating → taps Send → receiver sees a "Ready" card at Baking with the right qty; 5 parts go on Hold → job stays open until resolved → reworked/closed → one cert, one delivery.
+
+## Deployment
+
+Per-module `__manifest__.py` version bumps so the SCSS/asset bundle busts and any data reloads. Entech is native Odoo (LXC 111, DB `admin`) — standard `-u fusion_plating_shopfloor,fusion_plating_jobs,fusion_plating` upgrade. No data migration required (no new persistent fields; additive behaviours only).

fusion_plating/fusion_plating/__manifest__.py

@@ -5,7 +5,7 @@
 
 {
     'name': 'Fusion Plating',
-    'version': '19.0.22.1.0',
+    'version': '19.0.22.2.0',
     'category': 'Manufacturing/Plating',
     'summary': 'Core plating / metal finishing ERP: facilities, processes, tanks, baths, jobs, operators.',
     'description': """

fusion_plating/fusion_plating_jobs/__manifest__.py

@@ -3,7 +3,7 @@
 # License OPL-1 (Odoo Proprietary License v1.0)
 {
     'name': 'Fusion Plating — Native Jobs',
-    'version': '19.0.11.5.0',
+    'version': '19.0.11.6.0',
     'category': 'Manufacturing/Plating',
     'summary': 'Native plating job model — replaces mrp.production / mrp.workorder bridge.',
     'author': 'Nexa Systems Inc.',

fusion_plating/fusion_plating_jobs/models/fp_job.py

@@ -2074,11 +2074,27 @@ class FpJob(models.Model):
                 # the operator reconciles by hand. Mirrors the receiving
                 # `_update_job_qty_received` pattern: server fills the
                 # obvious default, operator owns the edge cases.
-                if (not job.qty_done and not job.qty_scrapped
+                # Partial-order handling (2026-06-02): surface scrap that
+                # was recorded through the Move log (transfer_type='scrap')
+                # into qty_scrapped, so the reconciliation + cert qty stay
+                # honest even when scrap was done from the tablet Move
+                # dialog rather than the qty_scrapped field. Only when the
+                # field hasn't been set by hand.
+                scrap_moves = job._fp_scrapped_via_moves()
+                if scrap_moves and not job.qty_scrapped:
+                    job.qty_scrapped = scrap_moves
+                # Clean-close auto-fill: derive the good (done) count from
+                # what physically came in minus scrap, instead of blindly
+                # assuming the whole order completed (which over-counts when
+                # parts were scrapped mid-line). Skips when the operator
+                # already typed qty_done, or when visual rejects make the
+                # split non-obvious — then the gate below makes them
+                # reconcile by hand.
+                if (not job.qty_done
                         and not (job.qty_visual_inspection_rejects or 0)
                         and job.qty_received
                         and abs(job.qty_received - job.qty) < 0.0001):
-                    job.qty_done = job.qty
+                    job.qty_done = job.qty - (job.qty_scrapped or 0)
                 accounted = (job.qty_done or 0) + (job.qty_scrapped or 0)
                 if abs(accounted - job.qty) > 0.0001:
                     raise UserError(_(
@@ -2439,6 +2455,19 @@ class FpJob(models.Model):
             fp_skip_step_gate=True,
         ).button_mark_done()
 
+    def _fp_scrapped_via_moves(self):
+        """Total parts scrapped through the Move log (transfer_type=
+        'scrap') for this job. Lets button_mark_done's reconciliation
+        count scrap done via the tablet Move dialog, not just the
+        qty_scrapped field (partial-order handling, 2026-06-02)."""
+        self.ensure_one()
+        Move = self.env['fp.job.step.move']
+        moves = Move.sudo().search([
+            ('job_id', '=', self.id),
+            ('transfer_type', '=', 'scrap'),
+        ])
+        return int(sum(m.qty_moved or 0 for m in moves))
+
     def _fp_check_advance_post_shop(self):
         """Auto-advance in_progress jobs whose recipe steps are all
         terminal. Called from fp.job.step.button_finish post-super().

fusion_plating/fusion_plating_jobs/models/fp_job_step.py

@@ -54,12 +54,37 @@ class FpJobStep(models.Model):
         # leak permissive behaviour through a related-field None.
         if not self.job_id:
             return True
+        # Partial-flow short-circuit (2026-06-02 partial-order handling).
+        # Once REAL parts have physically arrived at this step (a move
+        # parked them here), the predecessor lock is moot — the parts are
+        # on the floor at this station, so the step is startable
+        # regardless of whether upstream steps are fully done. This is
+        # what lets a partial group "light up" the next stage while the
+        # rest of the batch is still being processed upstream. Single
+        # source of truth: every caller (can_start, blocker, button_start,
+        # the Move dialog's _blockers_for_move) inherits this behaviour.
+        if self._fp_has_real_incoming():
+            return False
         recipe_seq = self.job_id.enforce_sequential
         if recipe_seq:
             return not self.parallel_start
         # Free-flow recipe — only the legacy per-step flag still gates.
         return bool(self.requires_predecessor_done)
 
+    def _fp_has_real_incoming(self):
+        """True when real parts have physically arrived at this step via
+        a move — an incoming move from a DIFFERENT step with qty_moved > 0.
+
+        Distinct from the qty_at_step first-step seed (a notional UI hint
+        with no backing move) and from self-loop measurement moves
+        (from_step == to_step, used by the Record Inputs wizard). Mirrors
+        the has_real_incoming test in core button_finish's qty gate.
+        """
+        self.ensure_one()
+        return bool(self.incoming_move_ids.filtered(
+            lambda m: m.from_step_id != self and (m.qty_moved or 0) > 0
+        ))
+
     def _fp_has_unfinished_predecessors(self):
         """True when an earlier-sequence step on the same job is not yet
         in a terminal state. Composes with _fp_should_block_predecessors
@@ -86,6 +111,10 @@ class FpJobStep(models.Model):
         'job_id.enforce_sequential',
         'job_id.step_ids.state',
         'job_id.step_ids.sequence',
+        # Partial-flow: arriving parts clear the predecessor gate
+        # (_fp_has_real_incoming), so can_start must recompute on move.
+        'incoming_move_ids.qty_moved',
+        'incoming_move_ids.from_step_id',
     )
     def _compute_can_start(self):
         for step in self:
@@ -128,33 +157,71 @@ class FpJobStep(models.Model):
     @api.depends(
         'work_centre_id.area_kind',
         'recipe_node_id.kind_id.area_kind',
+        'recipe_node_id.kind_id.code',
+        'sequence',
+        'job_id.step_ids.sequence',
+        'job_id.step_ids.work_centre_id.area_kind',
+        'job_id.step_ids.recipe_node_id.kind_id.area_kind',
+        'job_id.step_ids.recipe_node_id.kind_id.code',
     )
     def _compute_area_kind(self):
         """Resolve the plant-view column this step belongs in.
 
-        Priority chain:
+        Priority chain (non-gating steps):
           1. work_centre.area_kind (explicit operator setup wins)
           2. recipe_node.kind_id.area_kind (kind taxonomy authoritative)
           3. catch-all 'plating' (data integrity issue if we land here)
 
-        The legacy _STEP_KIND_TO_AREA dict was removed — fp.step.kind
-        now self-declares its area_kind, so the kind taxonomy IS the
-        source of truth. See spec
-        2026-05-24-shopfloor-live-step-fix-design.md Change 6.
+        Gating/marker steps (kind `code == 'gating'` — the "Ready for X"
+        steps) have NO physical location; the taxonomy maps them to
+        'receiving', which made a mid-recipe gate snap the job's card back
+        to the first column (Racking -> "Ready for processing" jumped to
+        Receiving, so the job looked like it vanished — 2026-06-02). A
+        gating step now FALLS FORWARD to the next non-gating step's column
+        (it's "ready for [that stage]"), keeping the card moving
+        left->right. If nothing real follows, it falls back to the last
+        real stage.
         """
         for step in self:
-            # 1. Explicit work_centre wins
-            if step.work_centre_id and step.work_centre_id.area_kind:
-                step.area_kind = step.work_centre_id.area_kind
-                continue
-            # 2. Kind taxonomy
-            node = step.recipe_node_id
-            if node and node.kind_id and node.kind_id.area_kind:
-                step.area_kind = node.kind_id.area_kind
-                continue
-            # 3. Catch-all — only reached for orphaned steps (no
-            # work_centre AND no recipe_node).
-            step.area_kind = 'plating'
+            step.area_kind = step._fp_resolve_area_kind()
+
+    def _fp_raw_area_kind(self):
+        """Area from this step's OWN work_centre / kind only — no look-ahead
+        and no dependence on the computed `area_kind` field (so the gating
+        fall-forward below can't recurse)."""
+        self.ensure_one()
+        if self.work_centre_id and self.work_centre_id.area_kind:
+            return self.work_centre_id.area_kind
+        node = self.recipe_node_id
+        if node and node.kind_id and node.kind_id.area_kind:
+            return node.kind_id.area_kind
+        return 'plating'
+
+    def _fp_is_gating_step(self):
+        """True for a 'Ready for X' marker step (no physical location).
+        Detected via the STABLE kind code, never the display name."""
+        self.ensure_one()
+        node = self.recipe_node_id
+        return bool(node and node.kind_id and node.kind_id.code == 'gating')
+
+    def _fp_resolve_area_kind(self):
+        """Column for this step: its own raw area, EXCEPT a gating marker
+        falls forward to the next non-gating step's column."""
+        self.ensure_one()
+        if not self._fp_is_gating_step():
+            return self._fp_raw_area_kind()
+        siblings = self.job_id.step_ids
+        later = siblings.filtered(
+            lambda s: s.sequence > self.sequence and not s._fp_is_gating_step()
+        ).sorted('sequence')
+        if later:
+            return later[0]._fp_raw_area_kind()
+        earlier = siblings.filtered(
+            lambda s: s.sequence < self.sequence and not s._fp_is_gating_step()
+        ).sorted('sequence')
+        if earlier:
+            return earlier[-1]._fp_raw_area_kind()
+        return self._fp_raw_area_kind()
 
     last_activity_at = fields.Datetime(
         string='Last Activity',
@@ -217,6 +284,9 @@ class FpJobStep(models.Model):
         'state', 'sequence', 'parallel_start', 'requires_predecessor_done',
         'job_id.enforce_sequential',
         'job_id.step_ids.state', 'job_id.step_ids.sequence',
+        # Partial-flow: arriving parts clear the predecessor gate.
+        'incoming_move_ids.qty_moved',
+        'incoming_move_ids.from_step_id',
     )
     def _compute_blocker(self):
         for step in self:
@@ -652,6 +722,52 @@ class FpJobStep(models.Model):
         ).sorted('sequence')
         return candidates[:1] or self.env['fp.job.step']
 
+    def _fp_try_autofinish_on_drain(self):
+        """Best-effort auto-finish when a step has drained to zero parked
+        parts (2026-06-02 partial-order handling).
+
+        Called by the Move controller after a bulk move commits. When the
+        last parts leave an in_progress step it should close itself — one
+        fewer tap for the operator. But finishing runs the full gate chain
+        (required inputs, sign-off, contract review, receiving, and the
+        post-shop close gates on the last step). If any gate isn't
+        satisfied we must NOT fail the move that already succeeded — so we
+        swallow the UserError and leave the step in_progress for the
+        operator to finish manually (the board will show it "running, 0
+        here", which reads as "finish me").
+
+        Fires for any step that actually moved parts OUT and drained to
+        zero — INCLUDING the first/seeded stage (its qty comes from the
+        qty_at_step seed, not a real incoming move). Returns True if the
+        step finished.
+        """
+        self.ensure_one()
+        if self.state != 'in_progress':
+            return False
+        # qty_at_step is a non-stored compute off the move rows — force a
+        # re-read so we see the just-committed outgoing move.
+        self.invalidate_recordset(['qty_at_step'])
+        if self.qty_at_step != 0:
+            return False
+        # Guard: only auto-finish a step that genuinely moved parts OUT (a
+        # real outgoing move, excluding self-loop measurement moves). The
+        # earlier guard checked _fp_has_real_incoming() — the WRONG
+        # direction: the first/seeded stage (e.g. Racking) is fed by the
+        # qty_at_step seed, not an incoming move, so it never auto-finished
+        # when all its parts were sent forward. Checking for a real
+        # OUTGOING move covers the seeded first stage correctly.
+        if not self.move_ids.filtered(
+                lambda m: m.to_step_id != self and (m.qty_moved or 0) > 0):
+            return False
+        try:
+            self.button_finish()
+            return True
+        except UserError:
+            # Gates still pending (missing prompts / sign-off / etc.) —
+            # leave the step in_progress for a manual finish. The move
+            # itself stands.
+            return False
+
     def _fp_has_uncaptured_step_inputs(self):
         """True when the recipe step has REQUIRED step_input prompts
         whose values haven't been recorded yet.

fusion_plating/fusion_plating_shopfloor/__manifest__.py

@@ -5,7 +5,7 @@
 
 {
     'name': 'Fusion Plating — Shop Floor',
-    'version': '19.0.36.1.1',
+    'version': '19.0.36.2.0',
     'category': 'Manufacturing/Plating',
     'summary': 'Shop-floor tablet stations, QR scanning, bake window enforcer.',
     'description': """

fusion_plating/fusion_plating_shopfloor/controllers/move_controller.py

@@ -124,8 +124,18 @@ class FpTabletMoveController(http.Controller):
             hasattr(to_step, '_fp_should_block_predecessors')
             and to_step._fp_should_block_predecessors()
         ):
+            # Partial-flow (2026-06-02): only an unfinished step STRICTLY
+            # BETWEEN from_step and to_step blocks the move (you'd be skipping
+            # an incomplete intermediate stage). The from_step itself is
+            # in-progress BY DEFINITION when advancing partial parts out of
+            # it — counting it (or any earlier step) as an "unfinished
+            # predecessor" blocked every partial advance to a not-yet-started
+            # next step. Steps before from_step are irrelevant: the parts
+            # being moved are physically at from_step, ready for the next
+            # stage. Backward moves (rework: from > to) yield an empty range
+            # and are never predecessor-blocked.
             unfinished = to_step.job_id.step_ids.filtered(
-                lambda s: s.sequence < to_step.sequence
+                lambda s: from_step.sequence < s.sequence < to_step.sequence
                 and s.state not in ('done', 'skipped', 'cancelled')
             )
             if unfinished:
@@ -147,7 +157,12 @@ class FpTabletMoveController(http.Controller):
         Step = request.env['fp.job.step']
         from_step = Step.browse(from_step_id)
         to_step = Step.browse(to_step_id)
-        qty = (from_step.qty_done or 0) - (from_step.qty_scrapped or 0)
+        # Available-to-move = parts currently parked here (qty_at_step —
+        # the exact number the operator sees on the card). The old
+        # qty_done − qty_scrapped read referenced step fields that don't
+        # exist on fp.job.step (always 0), which is why the move path was
+        # effectively unusable. See partial-order-handling design.
+        qty = from_step.qty_at_step or 0
         return {
             'ok': True,
             'qty_available': qty,
@@ -186,7 +201,7 @@ class FpTabletMoveController(http.Controller):
         if hard:
             raise UserError(hard[0]['message'])
 
-        qty_avail = (from_step.qty_done or 0) - (from_step.qty_scrapped or 0)
+        qty_avail = from_step.qty_at_step or 0
         move = Move.create({
             'job_id': from_step.job_id.id,
             'from_step_id': from_step.id,
@@ -214,6 +229,28 @@ class FpTabletMoveController(http.Controller):
         to_step.qty_at_step_start = (to_step.qty_at_step_start or 0) + qty
         from_step.qty_at_step_finish = (from_step.qty_at_step_finish or 0) + qty
 
+        # Partial-flow "light up" (2026-06-02 partial-order handling).
+        # A normal forward transfer that parks parts at the destination
+        # makes that stage actionable — flip pending -> ready so the
+        # receiving operator immediately sees a "Ready" card in their
+        # column with zero action by anyone. Never downgrade a step that
+        # is already past pending. Hold/scrap/rework/return route parts
+        # elsewhere and must NOT auto-ready a recipe step, so gate on
+        # transfer_type == 'step'.
+        if transfer_type == 'step' and to_step.state == 'pending':
+            to_step.state = 'ready'
+            # No auto-START — that begins the labour timer, which stays an
+            # explicit operator tap (keeps cost accurate; avoids the S16
+            # phantom-timer problem).
+
+        # Auto-finish the source when THIS forward move drained it to zero
+        # parked parts — one fewer tap. Best-effort: swallows finish-gate
+        # failures so the move always stands. Restricted to 'step' moves:
+        # a step drained by a HOLD still has unresolved held parts and
+        # must not auto-finish.
+        if transfer_type == 'step':
+            from_step._fp_try_autofinish_on_drain()
+
         # Manager-bypass audit trail
         ctx = request.env.context
         bypass_flags = [
@@ -279,7 +316,7 @@ class FpTabletMoveController(http.Controller):
             'batches': [
                 {
                     'step_id': s.id,
-                    'qty': (s.qty_done or 0) - (s.qty_scrapped or 0),
+                    'qty': s.qty_at_step or 0,
                     'part_number': (s.job_id.product_id.default_code or ''),
                     'wo_number': s.job_id.name or '',
                 }
@@ -343,7 +380,7 @@ class FpTabletMoveController(http.Controller):
 
         moves = []
         for batch in Step.search([('rack_id', '=', rack.id)]):
-            qty = (batch.qty_done or 0) - (batch.qty_scrapped or 0)
+            qty = batch.qty_at_step or 0
             move = Move.create({
                 'job_id': batch.job_id.id,
                 'from_step_id': batch.id,
@@ -353,9 +390,19 @@ class FpTabletMoveController(http.Controller):
                 'rack_id': rack.id,
                 'to_tank_id': to_tank_id or False,
             })
-            batch.qty_at_step_finish = qty
+            batch.qty_at_step_finish = (batch.qty_at_step_finish or 0) + qty
             to_step.qty_at_step_start = (to_step.qty_at_step_start or 0) + qty
             moves.append(move.id)
+            # Partial-flow "light up" — auto-finish the drained source
+            # batch (best-effort; see _fp_try_autofinish_on_drain).
+            if transfer_type == 'step':
+                batch._fp_try_autofinish_on_drain()
+
+        # Auto-ready the destination once parts have arrived (pending ->
+        # ready) so the receiving operator sees an actionable card. No
+        # auto-start (labour timer stays an explicit tap).
+        if transfer_type == 'step' and to_step.state == 'pending':
+            to_step.state = 'ready'
 
         rack.racking_state = 'in_use'
         return {'move_ids': moves, 'count': len(moves)}

fusion_plating/fusion_plating_shopfloor/controllers/plant_kanban.py

@@ -10,7 +10,7 @@ docs/superpowers/specs/2026-05-23-shopfloor-plant-view-design.md.
 """
 import json
 import logging
-from datetime import date, datetime, timedelta
+from datetime import date, datetime
 
 from odoo import _, http
 from odoo.http import request
@@ -110,19 +110,28 @@ class PlantKanbanController(http.Controller):
 
         jobs = Job.search(domain, limit=500)
 
-        # Bucket by area_kind of the active step (or 'receiving' when no
-        # active step yet — matches the contract_review / no_parts states
-        # that live in Receiving column per spec §3 D5).
+        # Partial-order handling (2026-06-02): a job shows up as a card in
+        # EVERY stage where it currently has parts (a "presence"), not just
+        # the single active-step column. Cards are keyed by a composite
+        # "{job_id}:{area}" so one job can appear in several columns. A job
+        # whose parts are all at one stage produces exactly one presence —
+        # byte-for-byte identical to the previous one-card-per-job board.
         cards = {}
         cards_by_area = {area: [] for area, _label in _COLUMN_LABELS}
         for job in jobs:
-            area = _resolve_card_area(job)
-            cards_by_area.setdefault(area, []).append(job.id)
-            cards[str(job.id)] = _render_card(job, paired)
+            active_area = (job.active_step_id.area_kind
+                           if job.active_step_id else _resolve_card_area(job))
+            for area, focus_step, qty_here in _job_presences(job):
+                key = '%s:%s' % (job.id, area)
+                cards[key] = _render_presence(
+                    job, area, focus_step, qty_here,
+                    area == active_area, paired,
+                )
+                cards_by_area.setdefault(area, []).append(key)
 
         # Sort within each column by priority then due date
         for area in cards_by_area:
-            cards_by_area[area].sort(key=lambda jid: _sort_key(cards[str(jid)]))
+            cards_by_area[area].sort(key=lambda k: _sort_key(cards[k]))
 
         columns = [
             {
@@ -251,21 +260,109 @@ def _resolve_card_area(job):
     return 'receiving'
 
 
-def _render_card(job, paired):
-    """Build the full card payload for one fp.job."""
-    # Sudo the job recordset so cross-module field reads (sale.order,
-    # fp.part.catalog, fusion.plating.customer.spec) don't AccessError
-    # for low-privilege roles like Technician. The output is denormalized
-    # display data; the underlying record visibility is controlled by the
-    # caller's fp.job ACL (Technician can read all jobs).
+def _job_presences(job):
+    """Return the list of (area, focus_step, qty_here) presences for a job.
+
+    One entry per Shop Floor area where the job currently has parts parked
+    OR an actionable (in_progress / paused / ready) step. This is what lets
+    a split job appear in several columns at once. A job whose parts are
+    all at one stage yields exactly ONE presence — byte-for-byte identical
+    to the previous one-card-per-job board.
+    """
+    job = job.sudo()
+    Step = job.env['fp.job.step']
+    # Post-shop + no-parts states are single-column, state-driven (mirrors
+    # _resolve_card_area). No per-stage fan-out once the job has cleared
+    # the line or hasn't received parts yet.
+    if job.card_state == 'no_parts':
+        return [('receiving', job.active_step_id, 0)]
+    if job.state == 'awaiting_cert':
+        return [('inspection', Step, 0)]
+    if job.state == 'awaiting_ship':
+        return [('shipping', Step, 0)]
+
+    open_steps = job.step_ids.filtered(
+        lambda s: s.state not in ('done', 'skipped', 'cancelled')
+    )
+    by_area = {}
+    for s in open_steps:
+        by_area.setdefault(s.area_kind or 'plating', []).append(s)
+
+    presences = []
+    for area, steps in by_area.items():
+        qty_here = sum((s.qty_at_step or 0) for s in steps)
+        # A stage shows ONLY where parts physically are (qty_here > 0 —
+        # which includes the first-active step's qty_at_step seed) OR where
+        # a step is actively being worked (in_progress / paused — e.g.
+        # drained to zero but not yet finished). A merely `ready` / `pending`
+        # step with NO parts is a FUTURE stage and must NOT show — otherwise
+        # the job appears in every not-yet-started step at once (these
+        # recipes seed all downstream steps to `ready`, so 6 ready steps =
+        # 6 phantom cards; bug on WO-30061). Strict sequential progress
+        # falls out for free because the qty_at_step seed always sits on the
+        # lowest-sequence non-terminal step and advances as each completes.
+        being_worked = any(
+            s.state in ('in_progress', 'paused') for s in steps
+        )
+        if qty_here > 0 or being_worked:
+            presences.append((area, _pick_focus_step(steps), qty_here))
+
+    if not presences:
+        # Nothing parked and nothing actionable — fall back to the single
+        # resolved column so the job never vanishes from the board.
+        return [(_resolve_card_area(job), job.active_step_id, 0)]
+    return presences
+
+
+def _pick_focus_step(steps):
+    """The most-actionable step in an area: in_progress > paused > ready >
+    pending, lowest sequence within a state. Drives the presence card's
+    step label, operator pill, and tap target (focus_step_id)."""
+    ordered = sorted(steps, key=lambda s: s.sequence or 0)
+    for state in ('in_progress', 'paused', 'ready', 'pending'):
+        for s in ordered:
+            if s.state == state:
+                return s
+    return ordered[0] if ordered else None
+
+
+def _secondary_card_state(step, paired):
+    """Card state for a NON-primary presence (a stage other than the job's
+    active step). Derived purely from the focus step so the operator at
+    that stage gets an honest 'running' / 'ready' chip. The PRIMARY
+    presence keeps the full job-level card_state (holds, QC, bake, etc.)."""
+    if not step:
+        return 'ready'
+    mine = bool(
+        paired and step.work_centre_id
+        and step.work_centre_id.id == paired.id
+    )
+    if step.state == 'in_progress':
+        return 'running_mine' if mine else 'running'
+    if step.state == 'paused':
+        return 'running'
+    # ready / pending → queued at this stage
+    return 'ready_mine' if mine else 'ready'
+
+
+def _render_presence(job, area, step, qty_here, is_primary, paired):
+    """Build a card payload for one (job, stage) presence.
+
+    The PRIMARY presence (the job's active-step column) carries the full
+    job-level card_state so every existing job-level signal (hold, QC,
+    bake-due, sign-off, idle, post-shop) renders exactly as before.
+    SECONDARY presences derive a simpler state from their own focus step.
+
+    Sudo the job so cross-module reads (sale.order, fp.part.catalog,
+    customer.spec) don't AccessError for low-privilege roles (Rule 13m) —
+    the output is denormalized display data; fp.job ACL gates visibility.
+    """
     job = job.sudo()
-    step = job.active_step_id
     try:
         timeline = json.loads(job.mini_timeline_json or '[]')
     except (TypeError, ValueError):
         timeline = []
 
-    # Cross-module field probes (sudo'd via job.sudo() above)
     part = job.part_catalog_id if 'part_catalog_id' in job._fields else None
     spec = job.customer_spec_id if 'customer_spec_id' in job._fields else None
     so = job.sale_order_id
@@ -274,10 +371,11 @@ def _render_card(job, paired):
     if so and 'x_fc_po_number' in so._fields:
         po_number = so.x_fc_po_number or ''
 
-    # Tag chips (Rush / FAIR / VIP / AS9100 — only render when applicable)
     tags = _compute_tags(job, part, spec)
 
-    # Step + tank labels
+    card_state = (job.card_state if is_primary
+                  else _secondary_card_state(step, paired))
+
     step_name = step.name if step else _('—')
     step_seq = step.sequence if step else 0
     step_total = len(job.step_ids)
@@ -285,23 +383,15 @@ def _render_card(job, paired):
     if step and step.work_centre_id:
         tank_label = step.work_centre_id.name or step.work_centre_id.code or ''
 
-    # State chip
-    state_chip = _state_chip(job.card_state, step)
+    state_chip = _state_chip(card_state, step)
 
-    # Operator pill (only when step has an assigned user)
     operator = None
     if step and step.assigned_user_id:
         u = step.assigned_user_id
-        operator = {
-            'id': u.id,
-            'name': u.name,
-            'initials': _initials_for(u),
-        }
+        operator = {'id': u.id, 'name': u.name, 'initials': _initials_for(u)}
 
-    # Icon row
     icons = _icons(job, step)
 
-    # Due label
     due_label = _due_label(job.date_deadline) if job.date_deadline else ''
     is_overdue = (
         bool(job.date_deadline)
@@ -311,9 +401,17 @@ def _render_card(job, paired):
 
     return {
         'job_id': job.id,
+        # Composite identity — one job can have several presences.
+        'card_key': '%s:%s' % (job.id, area),
+        'area_kind': area,
+        'is_primary': is_primary,
+        # Partial-order fields: parts parked at THIS stage vs whole job.
+        'qty_here': int(qty_here or 0),
+        'job_qty': int(job.qty or 0),
+        'focus_step_id': step.id if step else False,
         'wo_name': job.display_wo_name or job.name or '',
-        'is_mine': job.card_state in ('ready_mine', 'running_mine'),
-        'card_state': job.card_state or '',
+        'is_mine': card_state in ('ready_mine', 'running_mine'),
+        'card_state': card_state or '',
         'due_date': (job.date_deadline.strftime('%Y-%m-%d')
                      if job.date_deadline else None),
         'due_label': due_label,

fusion_plating/fusion_plating_shopfloor/controllers/workspace_controller.py

@@ -76,6 +76,11 @@ class FpWorkspaceController(http.Controller):
                 'kind': step.kind or 'other',
                 'kind_label': dict(step._fields['kind'].selection).get(step.kind, ''),
                 'state': step.state,
+                # Partial-order handling — parts currently parked at this
+                # step. Drives the "Send to next" button visibility + the
+                # per-step "N here" hint; the Move dialog pre-fills from the
+                # same number via the preview endpoint.
+                'qty_at_step': int(getattr(step, 'qty_at_step', 0) or 0),
                 'assigned_user_id': step.assigned_user_id.id or False,
                 'assigned_user_name': step.assigned_user_id.name or '',
                 'work_centre_name': step.work_centre_id.name or '',

fusion_plating/fusion_plating_shopfloor/static/src/js/components/plant_card.js

@@ -60,11 +60,15 @@ export class FpPlantCard extends Component {
     onCardClick() {
         const c = this.props.card;
         if (!c.job_id) return;
+        // Open the workspace focused on THIS stage's step (partial-order
+        // handling) — tapping the Baking card lands on the Baking step,
+        // not the job's global active step. The workspace already accepts
+        // focus_step_id (see the FP-STEP scan path in plant_kanban.js).
         this.action.doAction({
             type: "ir.actions.client",
             tag: "fp_job_workspace",
             target: "current",
-            params: { job_id: c.job_id },
+            params: { job_id: c.job_id, focus_step_id: c.focus_step_id || false },
         });
     }
 }

fusion_plating/fusion_plating_shopfloor/static/src/js/job_workspace.js

@@ -30,11 +30,12 @@ import { FpTabletLock } from "./tablet_lock";
 import { FpRackPartsDialog } from "./rack_parts_dialog";
 import { FpDamageDialog } from "./fp_damage_dialog";
 import { FpFinishBlockDialog } from "./fp_finish_block_dialog";
+import { FpMovePartsDialog } from "./move_parts_dialog";
 
 export class FpJobWorkspace extends Component {
     static template = "fusion_plating_shopfloor.JobWorkspace";
     static props = ["*"];
-    static components = { WorkflowChip, GateViz, FpSignaturePad, FpHoldComposer, FpTabletLock, FpRackPartsDialog, FpDamageDialog, FpFinishBlockDialog };
+    static components = { WorkflowChip, GateViz, FpSignaturePad, FpHoldComposer, FpTabletLock, FpRackPartsDialog, FpDamageDialog, FpFinishBlockDialog, FpMovePartsDialog };
 
     setup() {
         this.notification = useService("notification");
@@ -225,7 +226,21 @@ export class FpJobWorkspace extends Component {
         if (step.override_excluded) return [];
 
         const actions = [];
+        // Partial-order handling — "Send to next →" advances parts parked
+        // at this step to the next stage. Only shown when parts are here
+        // AND a next stage exists. The destination name is on the button
+        // so there's nothing to guess; qty defaults to all parked here.
+        const advanceAction = () => {
+            const nxt = this.nextStepFor(step);
+            if (nxt && (step.qty_at_step || 0) > 0) {
+                return { key: "advance", label: "Send → " + nxt.name,
+                         icon: "fa fa-arrow-right", cssClass: "btn btn-primary" };
+            }
+            return null;
+        };
         if (step.state === "in_progress") {
+            const adv = advanceAction();
+            if (adv) actions.push(adv);
             actions.push({ key: "record_inputs", label: "Record Inputs",
                            icon: "fa fa-pencil",  cssClass: "btn btn-secondary" });
             actions.push({ key: "pause",         label: "Pause",
@@ -240,6 +255,8 @@ export class FpJobWorkspace extends Component {
         if (step.state === "paused") {
             actions.push({ key: "resume",        label: "Resume",
                            icon: "fa fa-play",    cssClass: "btn btn-primary" });
+            const adv = advanceAction();
+            if (adv) actions.push(adv);
             actions.push({ key: "record_inputs", label: "Record Inputs",
                            icon: "fa fa-pencil",  cssClass: "btn btn-secondary" });
             actions.push({
@@ -281,6 +298,7 @@ export class FpJobWorkspace extends Component {
             case "mark_passed":          return this.onMarkPassed(step);
             case "open_contract_review": return this.onOpenContractReview(step);
             case "start_with_rack":      return this.onStartWithRack(step);
+            case "advance":              return this.onAdvanceStep(step);
         }
     }
 
@@ -463,6 +481,44 @@ export class FpJobWorkspace extends Component {
         });
     }
 
+    // ---- Partial-order advance (2026-06-02) -------------------------------
+    // "Send to next →" — moves parts parked at this step to the next stage.
+    // The destination auto-readies server-side (move_controller), so the
+    // receiving operator sees a Ready card immediately; the source
+    // auto-finishes when it drains to zero. Pure client-side next-step
+    // resolution off the loaded step list — no extra RPC.
+
+    nextStepFor(step) {
+        // The next stage parts flow into: lowest-sequence non-terminal step
+        // after this one. Returns null at the end of the line (parts finish
+        // in place there and close out at job mark-done).
+        const steps = (this.state.data && this.state.data.steps) || [];
+        const candidates = steps
+            .filter((s) => s.sequence > step.sequence
+                && ["pending", "ready", "paused", "in_progress"].includes(s.state))
+            .sort((a, b) => a.sequence - b.sequence);
+        return candidates.length ? candidates[0] : null;
+    }
+
+    onAdvanceStep(step) {
+        const nxt = this.nextStepFor(step);
+        if (!nxt) {
+            this.notification.add(
+                "This is the last stage — parts finish here and close out at job completion.",
+                { type: "warning" },
+            );
+            return;
+        }
+        // Open the slim Move dialog pre-set to advance to the next stage.
+        // Qty defaults to all parked here (qty_at_step) via the preview
+        // endpoint; the operator confirms or trims it with the steppers.
+        this.dialog.add(FpMovePartsDialog, {
+            fromStepId: step.id,
+            toStepId: nxt.id,
+            onCommit: async () => { await this.refresh(); },
+        });
+    }
+
     // ---- Receiving handlers (Spec C1+C2 2026-05-24) -----------------------
     // The receiver card at the top of the workspace lets the dock receiver
     // count boxes, set per-line received quantities + condition, log damage

fusion_plating/fusion_plating_shopfloor/static/src/js/move_parts_dialog.js

@@ -40,6 +40,11 @@ export class FpMovePartsDialog extends Component {
             promptValues: {},
             blockers: [],
             committing: false,
+            // Advanced fields (Transfer Type, To Location) stay collapsed
+            // by default — the everyday flow is "advance all to the next
+            // stage", which needs none of them. Keeps the dialog to a qty
+            // confirm + SEND for the 95% case.
+            showAdvanced: false,
         });
         onWillStart(async () => {
             await this.loadPreview();
@@ -152,4 +157,20 @@ export class FpMovePartsDialog extends Component {
                 { type: "warning" });
         }
     }
+
+    // ---- Qty steppers (no keyboard) ---------------------------------------
+    // The operator taps − / + or "All". Clamped to [1, qtyAvailable] so the
+    // count can never exceed what's parked here.
+    incQty() {
+        if (this.state.qty < this.state.qtyAvailable) this.state.qty += 1;
+    }
+    decQty() {
+        if (this.state.qty > 1) this.state.qty -= 1;
+    }
+    setQtyAll() {
+        this.state.qty = this.state.qtyAvailable;
+    }
+    toggleAdvanced() {
+        this.state.showAdvanced = !this.state.showAdvanced;
+    }
 }

fusion_plating/fusion_plating_shopfloor/static/src/scss/components/_gate_viz.scss

@@ -26,5 +26,5 @@ $_gate-text-hex:   #b06600;
 .o_fp_gate_icon  { color: $_gate-border-hex; margin-top: 0.15rem; }
 .o_fp_gate_body  { flex: 1; }
 .o_fp_gate_title { font-weight: 600; color: $_gate-text-hex; font-size: 0.85rem; }
-.o_fp_gate_reason { color: var(--text-secondary, #666); font-size: 0.78rem; margin-top: 0.1rem; }
+.o_fp_gate_reason { color: var(--bs-secondary-color, #666); font-size: 0.78rem; margin-top: 0.1rem; }
 .o_fp_gate_jump  { flex-shrink: 0; }

fusion_plating/fusion_plating_shopfloor/static/src/scss/components/_hold_composer.scss

@@ -17,5 +17,5 @@
 .o_fp_hc_row label {
     font-size: 0.8rem;
     font-weight: 600;
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
 }

fusion_plating/fusion_plating_shopfloor/static/src/scss/components/_kanban_card.scss

@@ -34,18 +34,18 @@ $_kc-hover-hex:  #f5f5f7;
 }
 
 .o_fp_kcard_h2 {
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
     font-size: 0.75rem;
     margin-top: 0.15rem;
 }
 
 .o_fp_kcard_qty {
     display: flex; justify-content: space-between;
-    font-size: 0.7rem; color: var(--text-secondary, #777);
+    font-size: 0.7rem; color: var(--bs-secondary-color, #777);
     margin-top: 0.3rem;
 }
 
-.o_fp_kcard_due { color: var(--text-secondary, #999); }
+.o_fp_kcard_due { color: var(--bs-secondary-color, #999); }
 
 .o_fp_kcard_bar {
     height: 4px; background: rgba(0,0,0,0.08);
@@ -74,7 +74,7 @@ $_kc-hover-hex:  #f5f5f7;
 }
 
 .o_fp_kcard_wc {
-    color: var(--text-secondary, #999);
+    color: var(--bs-secondary-color, #999);
     font-size: 0.7rem;
 }
 

fusion_plating/fusion_plating_shopfloor/static/src/scss/components/_pin_pad.scss

@@ -38,7 +38,7 @@ $_pin-dot-fill-hex: #1d1d1f;
 }
 
 .o_fp_pin_title    { font-size: 1.1rem; font-weight: 600; }
-.o_fp_pin_subtitle { font-size: 0.85rem; color: var(--text-secondary, #666); text-align: center; }
+.o_fp_pin_subtitle { font-size: 0.85rem; color: var(--bs-secondary-color, #666); text-align: center; }
 
 .o_fp_pin_dots {
     display: flex;
@@ -83,8 +83,8 @@ $_pin-dot-fill-hex: #1d1d1f;
     &:disabled { opacity: 0.5; cursor: wait; }
 }
 
-.o_fp_pin_key_clear  { font-size: 0.95rem; color: var(--text-secondary, #666); }
-.o_fp_pin_key_cancel { font-size: 0.95rem; color: var(--text-secondary, #666); }
+.o_fp_pin_key_clear  { font-size: 0.95rem; color: var(--bs-secondary-color, #666); }
+.o_fp_pin_key_cancel { font-size: 0.95rem; color: var(--bs-secondary-color, #666); }
 
 @keyframes o_fp_pin_shake_kf {
     0%, 100% { transform: translateX(0); }

fusion_plating/fusion_plating_shopfloor/static/src/scss/components/_plant_card.scss

@@ -91,6 +91,21 @@
     .card-sub-em { color: $plant-text; font-weight: 600; }
     .card-meta { font-size: 11px; color: $plant-muted; }
     .card-step { font-size: 14px; font-weight: 600; color: $plant-text; margin-top: 2px; }
+    // Partial-order handling — "20 of 50 here" per-stage count. The big
+    // number pops so an operator scanning their column instantly sees how
+    // many of a job's parts are at their station. Uses existing tokens so
+    // dark mode is handled at compile time by _plant_tokens.scss.
+    .card-qty-here {
+        font-size: 12px;
+        color: $plant-muted;
+        margin-top: 1px;
+        .qty-here-num {
+            font-size: 16px;
+            font-weight: 800;
+            color: $plant-mine-border;
+            letter-spacing: -0.01em;
+        }
+    }
     .card-chips { display: flex; flex-wrap: wrap; gap: 4px; }
 
     .chip {

fusion_plating/fusion_plating_shopfloor/static/src/scss/components/_signature_pad.scss

@@ -21,7 +21,7 @@ $_sig-canvas-border-hex: #d8dadd;
 
 .o_fp_sig_ctx {
     font-size: 0.85rem;
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
 }
 
 .o_fp_sig_canvas {
@@ -36,6 +36,6 @@ $_sig-canvas-border-hex: #d8dadd;
 
 .o_fp_sig_hint {
     font-size: 0.75rem;
-    color: var(--text-secondary, #999);
+    color: var(--bs-secondary-color, #999);
     text-align: center;
 }

fusion_plating/fusion_plating_shopfloor/static/src/scss/job_workspace.scss

@@ -29,7 +29,7 @@ $_ws-text-hex:   #1d1d1f;
 .o_fp_ws_loading {
     margin: auto;
     text-align: center;
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
 
     > div { margin-top: 0.6rem; }
 }
@@ -87,8 +87,8 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_ws_wo   { font-weight: 700; font-size: 1.3rem; letter-spacing: 0.01em; }
-.o_fp_ws_dot  { color: var(--text-secondary, #999); }
-.o_fp_ws_cust, .o_fp_ws_part { color: var(--text-secondary, #555); font-size: 0.95rem; }
+.o_fp_ws_dot  { color: var(--bs-secondary-color, #999); }
+.o_fp_ws_cust, .o_fp_ws_part { color: var(--bs-secondary-color, #555); font-size: 0.95rem; }
 
 .o_fp_ws_pill {
     background: linear-gradient(135deg, $_ws-card-hex 0%, $_ws-page-hex 100%);
@@ -97,7 +97,7 @@ $_ws-text-hex:   #1d1d1f;
     border-radius: 6px;
     font-size: 0.9rem;
     font-weight: 500;
-    color: var(--text-secondary, #555);
+    color: var(--bs-secondary-color, #555);
     box-shadow: 0 1px 2px rgba(0,0,0,0.04);
 }
 
@@ -152,7 +152,7 @@ $_ws-text-hex:   #1d1d1f;
     .o_fp_ws_bar_label {
         font-size: 0.8rem;
         font-weight: 500;
-        color: var(--text-secondary, #888);
+        color: var(--bs-secondary-color, #888);
         margin-top: 0.35rem;
         text-align: center;
     }
@@ -237,7 +237,7 @@ $_ws-text-hex:   #1d1d1f;
 .o_fp_ws_empty {
     text-align: center;
     padding: 2rem 1rem;
-    color: var(--text-secondary, #999);
+    color: var(--bs-secondary-color, #999);
 
     > div { margin-top: 0.5rem; }
 }
@@ -270,9 +270,9 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_ws_step_icon { width: 18px; text-align: center; font-weight: 700; }
-.o_fp_ws_step_num  { color: var(--text-secondary, #999); font-size: 0.78rem; min-width: 50px; }
+.o_fp_ws_step_num  { color: var(--bs-secondary-color, #999); font-size: 0.78rem; min-width: 50px; }
 .o_fp_ws_step_name { font-weight: 600; }
-.o_fp_ws_step_meta { color: var(--text-secondary, #999); font-size: 0.78rem; margin-left: auto; }
+.o_fp_ws_step_meta { color: var(--bs-secondary-color, #999); font-size: 0.78rem; margin-left: auto; }
 
 .o_fp_ws_step_badge {
     background: #0071e3;
@@ -295,12 +295,12 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_ws_step_chips   { display: flex; gap: 0.3rem; flex-wrap: wrap; }
-.o_fp_ws_step_instr   { font-size: 0.78rem; color: var(--text-secondary, #555); font-style: italic; }
+.o_fp_ws_step_instr   { font-size: 0.78rem; color: var(--bs-secondary-color, #555); font-style: italic; }
 .o_fp_ws_step_actions { display: flex; gap: 0.35rem; flex-wrap: wrap; }
 
 .o_fp_ws_step_excluded {
     font-size: 0.78rem;
-    color: var(--text-secondary, #888);
+    color: var(--bs-secondary-color, #888);
     font-style: italic;
 }
 
@@ -331,7 +331,7 @@ $_ws-text-hex:   #1d1d1f;
         font-size: 0.7rem;
         text-transform: uppercase;
         letter-spacing: 0.04em;
-        color: var(--text-secondary, #777);
+        color: var(--bs-secondary-color, #777);
         margin-bottom: 0.35rem;
     }
 }
@@ -362,14 +362,14 @@ $_ws-text-hex:   #1d1d1f;
     display: flex;
     gap: 0.4rem;
     font-size: 0.72rem;
-    color: var(--text-secondary, #777);
+    color: var(--bs-secondary-color, #777);
 }
 
 .o_fp_ws_note .author { font-weight: 600; }
-.o_fp_ws_note .body   { color: var(--text-secondary, #555); margin-top: 0.15rem; }
+.o_fp_ws_note .body   { color: var(--bs-secondary-color, #555); margin-top: 0.15rem; }
 
 .o_fp_ws_empty_small {
-    color: var(--text-secondary, #999);
+    color: var(--bs-secondary-color, #999);
     font-size: 0.75rem;
     font-style: italic;
 }
@@ -417,7 +417,7 @@ $_ws-text-hex:   #1d1d1f;
         align-items: center;
         gap: 0.4rem;
         font-size: 0.85rem;
-        color: var(--text-secondary, #777);
+        color: var(--bs-secondary-color, #777);
     }
 
     .o_fp_ws_ship_fields {
@@ -488,8 +488,8 @@ $_ws-text-hex:   #1d1d1f;
 .o_fp_ws_rcv_status {
     padding: 0.2rem 0.6rem;
     border-radius: 4px;
-    background: #fef3c7;
-    color: #78350f;
+    background-color: color-mix(in srgb, #f59e0b 18%, var(--bs-body-bg));
+    color: var(--bs-body-color);
     font-weight: 600;
     font-size: 0.85rem;
     text-transform: uppercase;
@@ -507,7 +507,7 @@ $_ws-text-hex:   #1d1d1f;
 
     label {
         font-weight: 600;
-        color: var(--text-secondary, #555);
+        color: var(--bs-secondary-color, #555);
         font-size: 0.9rem;
     }
 }
@@ -529,7 +529,7 @@ $_ws-text-hex:   #1d1d1f;
     font-size: 0.8rem;
     font-weight: 700;
     text-transform: uppercase;
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
     margin-bottom: 0.5rem;
     letter-spacing: 0.05em;
 }
@@ -598,7 +598,7 @@ $_ws-text-hex:   #1d1d1f;
     font-weight: 700;
     text-transform: uppercase;
     letter-spacing: 0.05em;
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
     margin-bottom: 0.5rem;
     display: flex;
     align-items: center;
@@ -644,7 +644,7 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_ws_rcv_damage_photos {
-    color: var(--text-secondary, #666);
+    color: var(--bs-secondary-color, #666);
     font-size: 0.85rem;
 }
 
@@ -680,7 +680,7 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_dmg_field { display: flex; flex-direction: column; gap: 0.4rem; }
-.o_fp_dmg_label { font-weight: 600; color: var(--text-secondary, #555); }
+.o_fp_dmg_label { font-weight: 600; color: var(--bs-secondary-color, #555); }
 .o_fp_dmg_req { color: #dc2626; }
 
 .o_fp_dmg_pills {
@@ -784,8 +784,8 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_ws_step_timer_over {
-    background: #fee2e2;
-    color: #7f1d1d;
+    background-color: color-mix(in srgb, #ef4444 16%, var(--bs-body-bg));
+    color: var(--bs-body-color);
     animation: o_fp_ws_timer_pulse 1.5s ease-in-out infinite;
 }
 
@@ -806,17 +806,25 @@ $_ws-text-hex:   #1d1d1f;
     gap: 1rem;
 }
 
+// NOTE: Odoo's backend CSS does NOT define --bs-body-color /
+// --bs-secondary-color / --bs-*-bg as custom properties (verified: 0
+// definitions in the compiled bundle — they're SCSS literals + two
+// bundles + [data-bs-theme]). So var(--bs-body-color, #hex) ALWAYS
+// resolves to the dark #hex fallback, in light AND dark mode. The fix
+// for dialog text is to INHERIT the modal's theme-correct colour (the
+// dialog title and the "Count the Parts" list items do exactly this and
+// are readable in both modes). Tinted boxes use translucent rgba() so
+// they work over whatever the live theme background is.
 .o_fp_finish_block_step {
     font-size: 1.1rem;
-    color: #b45309;
-    background: #fef3c7;
+    background-color: rgba(245, 158, 11, 0.16);
     padding: 0.7rem 1rem;
     border-radius: 6px;
     border-left: 4px solid #f59e0b;
 }
 
 .o_fp_finish_block_msg {
-    color: var(--text-secondary, #333);
+    font-weight: 500;
 }
 
 .o_fp_finish_block_list {
@@ -831,9 +839,9 @@ $_ws-text-hex:   #1d1d1f;
 }
 
 .o_fp_finish_block_action_note {
-    color: var(--text-secondary, #555);
+    // Inherit text colour; translucent neutral box works in both themes.
     font-style: italic;
     padding: 0.6rem 0.8rem;
-    background: #f3f4f6;
+    background: rgba(128, 128, 128, 0.12);
     border-radius: 4px;
 }

fusion_plating/fusion_plating_shopfloor/static/src/scss/move_dialogs.scss

@@ -173,3 +173,89 @@ $fp-md-page:   var(--fp-page-bg, #{$_fp_md_page_hex});
         }
     }
 }
+
+// ============================ Partial-order handling — easy-advance layout
+// "Send Parts Forward" dialog: destination banner + big-tap qty stepper
+// (no keyboard) + collapsed advanced fields. Reuses the $fp-md-* tokens so
+// dark mode is handled at compile time.
+.o_fp_move_dialog {
+    .o_fp_move_route {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        gap: .5rem;
+        flex-wrap: wrap;
+        padding: .6rem .75rem;
+        background: $fp-md-page;
+        border: 1px solid $fp-md-border;
+        border-radius: 6px;
+        font-weight: 600;
+
+        .route-from { color: $fp-md-muted; }
+        .route-arrow { color: $fp-md-accent; font-weight: 800; }
+        .route-to { color: $fp-md-accent; }
+    }
+
+    .o_fp_move_qty {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: .35rem;
+
+        label { font-weight: 600; margin: 0; }
+    }
+
+    .o_fp_qty_stepper {
+        display: flex;
+        align-items: center;
+        gap: .5rem;
+
+        .qty-btn {
+            width: 3rem;
+            height: 3rem;
+            font-size: 1.5rem;
+            font-weight: 700;
+            line-height: 1;
+            border: 1px solid $fp-md-border;
+            border-radius: 8px;
+            background: $fp-md-card;
+            color: $fp-md-accent;
+
+            &:disabled { opacity: .4; }
+        }
+        .qty-value {
+            min-width: 3.5rem;
+            text-align: center;
+            font-size: 1.75rem;
+            font-weight: 800;
+        }
+        .qty-all {
+            margin-left: .5rem;
+            padding: .5rem .9rem;
+            border: 1px solid $fp-md-border;
+            border-radius: 8px;
+            background: $fp-md-card;
+            font-weight: 600;
+        }
+    }
+
+    .o_fp_qty_hint {
+        color: $fp-md-muted;
+        font-size: .85rem;
+    }
+
+    .o_fp_move_advanced_toggle {
+        text-align: center;
+
+        .btn-link { color: $fp-md-muted; text-decoration: none; }
+    }
+
+    .o_fp_move_advanced {
+        display: flex;
+        flex-direction: column;
+        gap: .5rem;
+        padding: .6rem .75rem;
+        border: 1px dashed $fp-md-border;
+        border-radius: 6px;
+    }
+}

fusion_plating/fusion_plating_shopfloor/static/src/scss/plant_kanban.scss

@@ -72,6 +72,8 @@
         }
     }
     .toolbar-btn {
+        display: inline-flex;
+        align-items: center;
         padding: 8px 14px;
         font-size: 14px;
         font-weight: 500;
@@ -81,8 +83,10 @@
         cursor: pointer;
         color: $plant-text;
         font-family: inherit;
+        white-space: nowrap;
         box-shadow: 0 1px 2px rgba(0,0,0,0.05);
         transition: transform 0.1s ease, box-shadow 0.1s ease;
+        i { font-size: 15px; line-height: 1; }
         &:hover {
             transform: translateY(-1px);
             box-shadow: 0 2px 4px rgba(0,0,0,0.08);
@@ -93,6 +97,24 @@
             color: #5e4400;
             font-weight: 700;
         }
+        // Scan pair — matched look. "Scan QR" (camera, the primary way to
+        // scan a printed job sticker) is accent-filled so it stands out;
+        // "Enter Code" (manual / hardware scanner-gun) is the accent-tinted
+        // secondary. Matched FA icons (fa-qrcode / fa-keyboard-o), no emoji.
+        &.o_fp_qr_btn {
+            background: linear-gradient(135deg, #2563eb 0%, #1d4ed8 100%);
+            border-color: #1d4ed8;
+            color: #fff;
+            font-weight: 600;
+            i { color: #fff; }
+            &:hover { box-shadow: 0 3px 8px rgba(29, 78, 216, 0.32); }
+        }
+        &.scan-alt {
+            background: linear-gradient(135deg, $plant-mine-bg 0%, $plant-card-bg 100%);
+            border-color: $plant-mine-border;
+            font-weight: 600;
+            i { color: #1d4ed8; }
+        }
     }
 
     // 8 tiles — Work Orders, At My Station, Bakes Due, On Hold,

fusion_plating/fusion_plating_shopfloor/static/src/xml/components/plant_card.xml

@@ -47,6 +47,14 @@
             <!-- Step name -->
             <div class="card-step" t-esc="props.card.step_name"/>
 
+            <!-- Parts at THIS stage (partial-order handling). "20 of 50"
+                 so a per-stage presence is never mistaken for a whole job.
+                 Hidden when nothing is parked here (post-shop / empty). -->
+            <div t-if="props.card.qty_here" class="card-qty-here">
+                <span class="qty-here-num" t-esc="props.card.qty_here"/>
+                <span class="qty-here-of"> of <t t-esc="props.card.job_qty"/> here</span>
+            </div>
+
             <!-- Tank + state chip -->
             <div class="card-chips">
                 <span t-if="props.card.tank_label" class="chip tank" t-esc="props.card.tank_label"/>

fusion_plating/fusion_plating_shopfloor/static/src/xml/move_parts_dialog.xml

@@ -2,75 +2,48 @@
 <templates xml:space="preserve">
 
 <t t-name="fusion_plating_shopfloor.FpMovePartsDialog">
-    <Dialog title.translate="Move Parts" size="'lg'">
+    <Dialog title.translate="Send Parts Forward" size="'md'">
         <div class="o_fp_move_dialog" t-if="!state.loading">
 
-            <div class="o_fp_move_field">
-                <label>Part Count</label>
-                <input type="number" t-model.number="state.qty"
-                       t-att-min="1" t-att-max="state.qtyAvailable"/>
-                <span class="text-muted">Available: <t t-esc="state.qtyAvailable"/></span>
+            <!-- Destination banner — operator sees exactly where parts go,
+                 nothing to guess. -->
+            <div class="o_fp_move_route">
+                <span class="route-from" t-esc="state.fromStep.name"/>
+                <span class="route-arrow"> → </span>
+                <span class="route-to" t-esc="state.toStep.name"/>
             </div>
 
-            <div class="o_fp_move_field">
-                <label>From Node</label>
-                <span t-esc="state.fromStep.name"/>
-                <span/>
-            </div>
-
-            <div class="o_fp_move_field" t-if="state.fromStep.tank_name">
-                <label>From Station</label>
-                <span t-esc="state.fromStep.tank_name"/>
-                <span/>
-            </div>
-
-            <div class="o_fp_move_field">
-                <label>Transfer Type</label>
-                <select t-model="state.transferType">
-                    <option value="step">Step</option>
-                    <option value="hold">Hold</option>
-                    <option value="scrap">Scrap</option>
-                    <option value="rework">Rework</option>
-                    <option value="split">Split</option>
-                    <option value="return">Return</option>
-                </select>
-                <span/>
-            </div>
-
-            <div class="o_fp_move_field">
-                <label>To Node</label>
-                <span t-esc="state.toStep.name"/>
-                <span/>
+            <!-- Qty stepper — no keyboard. Defaults to all parked here. -->
+            <div class="o_fp_move_qty">
+                <label>How many to send?</label>
+                <div class="o_fp_qty_stepper">
+                    <button class="qty-btn" t-on-click="decQty"
+                            t-att-disabled="state.qty &lt;= 1">−</button>
+                    <span class="qty-value" t-esc="state.qty"/>
+                    <button class="qty-btn" t-on-click="incQty"
+                            t-att-disabled="state.qty &gt;= state.qtyAvailable">+</button>
+                    <button class="qty-all" t-on-click="setQtyAll">
+                        All (<t t-esc="state.qtyAvailable"/>)
+                    </button>
+                </div>
+                <span class="o_fp_qty_hint"><t t-esc="state.qtyAvailable"/> parked here</span>
             </div>
 
+            <!-- To Station (tank) — only when the recipe offers a choice -->
             <div class="o_fp_move_field"
                  t-if="state.toStep.tank_options and state.toStep.tank_options.length > 1">
                 <label>To Station</label>
                 <select t-model.number="state.toTankId">
-                    <t t-foreach="state.toStep.tank_options"
-                       t-as="tk" t-key="tk.id">
+                    <t t-foreach="state.toStep.tank_options" t-as="tk" t-key="tk.id">
                         <option t-att-value="tk.id"><t t-esc="tk.name"/></option>
                     </t>
                 </select>
-                <span/>
             </div>
 
-            <div class="o_fp_move_field">
-                <label>To Location</label>
-                <select t-model="state.toLocation">
-                    <option value="global">Global</option>
-                    <option value="quarantine">Quarantine</option>
-                    <option value="staging_a">Staging A</option>
-                    <option value="staging_b">Staging B</option>
-                    <option value="shipping_dock">Shipping Dock</option>
-                    <option value="scrap_bin">Scrap Bin</option>
-                </select>
-                <span/>
-            </div>
-
-            <div class="o_fp_compliance_prompts"
-                 t-if="state.transitionPrompts.length">
-                <h5>Compliance Prompts</h5>
+            <!-- Compliance prompts — only when the recipe author required
+                 them. Pickers/checkboxes, minimal free text. -->
+            <div class="o_fp_compliance_prompts" t-if="state.transitionPrompts.length">
+                <h5>Required before sending</h5>
                 <t t-foreach="state.transitionPrompts" t-as="p" t-key="p.id">
                     <div class="o_fp_move_field">
                         <label>
@@ -94,13 +67,12 @@
                             </t>
                         </select>
                         <span class="text-muted" t-if="p.hint"><t t-esc="p.hint"/></span>
-                        <span t-else=""/>
                     </div>
                 </t>
             </div>
 
+            <!-- Blockers — inline resolve where possible -->
             <div class="o_fp_blockers" t-if="state.blockers.length">
-                <h5>Blockers</h5>
                 <t t-foreach="state.blockers" t-as="b" t-key="b_index">
                     <div class="o_fp_blocker_row"
                          t-att-class="b.severity === 'hard' ? 'o_fp_blocker_hard' : 'o_fp_blocker_soft'">
@@ -114,6 +86,39 @@
                     </div>
                 </t>
             </div>
+
+            <!-- More options (advanced) — hold / scrap / rework / location.
+                 Collapsed by default so the everyday "advance all" flow is
+                 a qty confirm + SEND. -->
+            <div class="o_fp_move_advanced_toggle">
+                <button class="btn btn-link btn-sm" t-on-click="toggleAdvanced">
+                    <t t-if="state.showAdvanced">▾ Hide options</t>
+                    <t t-else="">▸ More options (hold / scrap / location)</t>
+                </button>
+            </div>
+            <div t-if="state.showAdvanced" class="o_fp_move_advanced">
+                <div class="o_fp_move_field">
+                    <label>Transfer Type</label>
+                    <select t-model="state.transferType">
+                        <option value="step">Send to next step</option>
+                        <option value="hold">Hold</option>
+                        <option value="scrap">Scrap</option>
+                        <option value="rework">Rework</option>
+                        <option value="return">Return</option>
+                    </select>
+                </div>
+                <div class="o_fp_move_field">
+                    <label>To Location</label>
+                    <select t-model="state.toLocation">
+                        <option value="global">Global</option>
+                        <option value="quarantine">Quarantine</option>
+                        <option value="staging_a">Staging A</option>
+                        <option value="staging_b">Staging B</option>
+                        <option value="shipping_dock">Shipping Dock</option>
+                        <option value="scrap_bin">Scrap Bin</option>
+                    </select>
+                </div>
+            </div>
         </div>
 
         <div t-if="state.loading">Loading…</div>
@@ -126,7 +131,7 @@
                     t-att-disabled="!canCommit"
                     t-att-title="blockerTooltip"
                     t-on-click="onCommit">
-                MOVE (<t t-esc="state.qty"/>)
+                SEND (<t t-esc="state.qty"/>)
             </button>
         </t>
     </Dialog>

fusion_plating/fusion_plating_shopfloor/static/src/xml/plant_kanban.xml

@@ -23,13 +23,18 @@
                                     <button t-att-class="modeClass('manager')"
                                             t-on-click="() => this.setMode('manager')">Manager</button>
                                 </div>
-                                <!-- Text/wedge scan drawer toggle. Camera path
-                                     is the QrScanner inline below — it
-                                     opens its own modal + decoder. -->
-                                <button class="toolbar-btn"
-                                        t-att-class="state.showScan ? 'toolbar-btn active' : 'toolbar-btn'"
-                                        t-on-click="toggleScan">⌨️ Scan Code</button>
-                                <QrScanner cssClass="'toolbar-btn'" label="'📷 Camera'"/>
+                                <!-- "Scan QR" = the QrScanner camera path (the
+                                     primary way to scan a printed job sticker).
+                                     The component renders its own fa-qrcode
+                                     icon, so the label must be plain text — an
+                                     emoji here would double up the icon.
+                                     "Enter Code" = the manual / hardware-scanner-
+                                     gun text drawer (a wedge gun types the code;
+                                     no camera). -->
+                                <QrScanner cssClass="'toolbar-btn'" label="'Scan QR'"/>
+                                <button class="toolbar-btn scan-alt"
+                                        t-att-class="state.showScan ? 'active' : ''"
+                                        t-on-click="toggleScan"><i class="fa fa-keyboard-o me-1"/>Enter Code</button>
                                 <button class="toolbar-btn handoff" t-on-click="onHandOff">🔓 Hand Off</button>
                             </div>
                         </div>

fusion_portal/__manifest__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 {
     'name': 'Fusion Authorizer & Sales Portal',
-    'version': '19.0.2.8.0',
+    'version': '19.0.2.10.1',
     'category': 'Sales/Portal',
     'summary': 'Portal for Authorizers (OTs) and Sales Reps with Assessment Forms',
     'description': """
@@ -64,12 +64,14 @@ This module provides external portal access for:
         'data/portal_menu_data.xml',
         'data/ir_actions_server_data.xml',
         'data/welcome_articles.xml',
+        'data/visit_data.xml',
         # Views
         'views/res_partner_views.xml',
         'views/sale_order_views.xml',
         'views/assessment_views.xml',
         'views/loaner_checkout_views.xml',
         'views/pdf_template_views.xml',
+        'views/visit_views.xml',
         # Portal Templates
         'views/portal_templates.xml',
         'views/portal_assessment_express.xml',
@@ -79,6 +81,7 @@ This module provides external portal access for:
         'views/portal_technician_templates.xml',
         'views/portal_book_assessment.xml',
         'views/portal_page11_sign_templates.xml',
+        'views/portal_visit.xml',
     ],
     'assets': {
         'web.assets_backend': [

fusion_portal/controllers/portal_assessment.py

@@ -458,6 +458,7 @@ class AssessmentPortal(CustomerPortal):
             'current_page': 1,
             'total_pages': 2,
             'assessment': None,
+            'visit_id': kw.get('visit_id', ''),
             'google_maps_api_key': google_maps_api_key,
         }
         
@@ -516,6 +517,7 @@ class AssessmentPortal(CustomerPortal):
             'partner': partner,
             'user': user,
             'assessment': assessment,
+            'visit_id': kw.get('visit_id') or (assessment.visit_id.id if assessment.visit_id else ''),
             'authorizers': authorizers,
             'authorizers_json': authorizers_json,
             'clients': clients,
@@ -630,6 +632,30 @@ class AssessmentPortal(CustomerPortal):
                 except Exception as e:
                     _logger.error(f"Error saving Page 11 signature: {e}")
 
+            # ===== Visit-linked: defer SO creation to visit completion =====
+            # Started from a visit workspace: do NOT complete into a standalone
+            # sale order. Leave it as a draft linked to the visit so
+            # visit.action_complete_visit() groups the visit's ADP devices
+            # (combination-checked) into ONE ADP order. The Page 11 signature is
+            # already saved above; pre-generate its PDF so it is ready.
+            if assessment.visit_id and action == 'submit':
+                if assessment.signature_page_11 and assessment.consent_declaration_accepted:
+                    try:
+                        pdf_bytes = assessment.generate_template_pdf('Page 11')
+                        if pdf_bytes:
+                            import base64 as b64
+                            assessment.write({
+                                'signed_page_11_pdf': b64.b64encode(pdf_bytes),
+                                'signed_page_11_pdf_filename': f'ADP_Page11_{assessment.reference}.pdf',
+                            })
+                    except Exception as pdf_e:
+                        _logger.warning(f"Visit-linked Page 11 PDF generation failed (non-blocking): {pdf_e}")
+                _logger.info(
+                    f"Express assessment {assessment.reference} saved to visit "
+                    f"{assessment.visit_id.name} (completion deferred to visit)"
+                )
+                return request.redirect(f'/my/visit/{assessment.visit_id.id}')
+
             # Handle navigation
             if action == 'submit':
                 # If already completed, we just saved consent/signature above -- redirect with success
@@ -803,6 +829,13 @@ class AssessmentPortal(CustomerPortal):
     def _build_express_assessment_vals(self, kw):
         """Build values dict from express form POST data"""
         vals = {}
+
+        # Visit linkage (assessment started from a visit workspace)
+        if kw.get('visit_id'):
+            try:
+                vals['visit_id'] = int(kw.get('visit_id'))
+            except (ValueError, TypeError):
+                pass
         
         # Equipment type
         if kw.get('equipment_type'):
@@ -815,7 +848,15 @@ class AssessmentPortal(CustomerPortal):
             vals['wheelchair_type'] = kw.get('wheelchair_type')
         if kw.get('powerchair_type'):
             vals['powerchair_type'] = kw.get('powerchair_type')
-        
+        if kw.get('scooter_type'):
+            vals['scooter_type'] = kw.get('scooter_type')
+        if kw.get('scooter_max_range'):
+            vals['scooter_max_range'] = float(kw.get('scooter_max_range') or 0)
+        if kw.get('x_fc_power_home_accessible'):
+            vals['x_fc_power_home_accessible'] = kw.get('x_fc_power_home_accessible')
+        if kw.get('x_fc_power_home_access_notes'):
+            vals['x_fc_power_home_access_notes'] = kw.get('x_fc_power_home_access_notes')
+
         # Float measurements
         float_fields = [
             'rollator_handle_height', 'rollator_seat_height',

fusion_portal/controllers/portal_main.py

@@ -2479,6 +2479,56 @@ class AuthorizerPortal(CustomerPortal):
         template = template_map.get(assessment_type, 'fusion_portal.portal_accessibility_selector')
         return request.render(template, values)
     
+    # ==========================================================================
+    # ASSESSMENT VISIT WORKSPACE (Phase 1b/3)
+    # ==========================================================================
+    @http.route('/my/visit/new', type='http', auth='user', website=True)
+    def visit_new(self, **kw):
+        """Start a new assessment visit and open its workspace."""
+        partner = request.env.user.partner_id
+        if not partner.is_sales_rep_portal and not partner.is_authorizer:
+            return request.redirect('/my')
+        visit = request.env['fusion.assessment.visit'].sudo().create({
+            'sales_rep_id': request.env.user.id,
+        })
+        return request.redirect('/my/visit/%s' % visit.id)
+
+    @http.route('/my/visit/<int:visit_id>', type='http', auth='user', website=True)
+    def visit_workspace(self, visit_id, **kw):
+        visit = request.env['fusion.assessment.visit'].sudo().browse(visit_id)
+        if not visit.exists():
+            return request.redirect('/my')
+        return request.render('fusion_portal.portal_visit_workspace', {
+            'visit': visit,
+            'page_name': 'visit',
+            'error': kw.get('error'),
+        })
+
+    @http.route('/my/visit/<int:visit_id>/save', type='http', auth='user', methods=['POST'], website=True, csrf=True)
+    def visit_save_client(self, visit_id, **post):
+        visit = request.env['fusion.assessment.visit'].sudo().browse(visit_id)
+        if visit.exists():
+            visit.write({
+                'client_name': (post.get('client_name') or '').strip(),
+                'client_phone': (post.get('client_phone') or '').strip(),
+                'client_email': (post.get('client_email') or '').strip(),
+                'client_address': (post.get('client_address') or '').strip(),
+                'x_fc_income_under_mod_threshold': post.get('x_fc_income_under_mod_threshold') or 'unknown',
+            })
+        return request.redirect('/my/visit/%s' % visit_id)
+
+    @http.route('/my/visit/<int:visit_id>/complete', type='http', auth='user', methods=['POST'], website=True, csrf=True)
+    def visit_complete(self, visit_id, **post):
+        visit = request.env['fusion.assessment.visit'].sudo().browse(visit_id)
+        if not visit.exists():
+            return request.redirect('/my')
+        try:
+            visit.action_complete_visit()
+        except Exception as e:
+            _logger.warning("Visit %s completion failed: %s", visit_id, e)
+            return request.redirect('/my/visit/%s?error=%s' % (visit_id, str(e)))
+        return request.redirect('/my/visit/%s' % visit_id)
+
     @http.route('/my/accessibility/save', type='json', auth='user', methods=['POST'], csrf=True)
     def accessibility_assessment_save(self, **post):
         """Save an accessibility assessment and optionally create a Sale Order"""
@@ -2493,7 +2543,14 @@ class AuthorizerPortal(CustomerPortal):
             assessment_type = post.get('assessment_type')
             if not assessment_type:
                 return {'success': False, 'error': 'Assessment type is required'}
-            
+
+            # Funding source drives the downstream sale-order workflow; coerce
+            # anything unexpected to private pay (mirrors /book-assessment).
+            _funding_keys = dict(Assessment._fields['x_fc_funding_source'].selection)
+            funding_source = post.get('funding_source') or 'direct_private'
+            if funding_source not in _funding_keys:
+                funding_source = 'direct_private'
+
             # Build assessment values
             vals = {
                 'assessment_type': assessment_type,
@@ -2507,6 +2564,7 @@ class AuthorizerPortal(CustomerPortal):
                 'client_address_postal': post.get('client_address_postal', '').strip(),
                 'client_phone': post.get('client_phone', '').strip(),
                 'client_email': post.get('client_email', '').strip(),
+                'x_fc_funding_source': funding_source,
                 'notes': post.get('notes', '').strip(),
             }
             
@@ -2539,6 +2597,13 @@ class AuthorizerPortal(CustomerPortal):
             if partner.is_authorizer:
                 vals['authorizer_id'] = partner.id
             
+            # Link to a visit if this form was launched from the workspace.
+            if post.get('visit_id'):
+                try:
+                    vals['visit_id'] = int(post.get('visit_id'))
+                except (TypeError, ValueError):
+                    pass
+
             # Create the assessment
             assessment = Assessment.create(vals)
             _logger.info(f"Created accessibility assessment {assessment.reference} by {request.env.user.name}")
@@ -2564,8 +2629,12 @@ class AuthorizerPortal(CustomerPortal):
             if video_data:
                 self._attach_accessibility_video(assessment, video_data, video_filename)
             
-            # Complete the assessment and create Sale Order if requested
+            # Complete the assessment and create Sale Order if requested.
+            # When launched from a visit, always save as a draft linked to the
+            # visit — the VISIT completion creates the grouped sale order(s).
             create_sale_order = post.get('create_sale_order', True)
+            if vals.get('visit_id'):
+                create_sale_order = False
             if create_sale_order:
                 sale_order = assessment.action_complete()
                 return {
@@ -2578,12 +2647,13 @@ class AuthorizerPortal(CustomerPortal):
                     'redirect_url': f'/my/sales/case/{sale_order.id}',
                 }
             else:
+                redirect_url = ('/my/visit/%s' % vals['visit_id']) if vals.get('visit_id') else '/my/accessibility/list'
                 return {
                     'success': True,
                     'assessment_id': assessment.id,
                     'assessment_ref': assessment.reference,
-                    'message': f'Assessment {assessment.reference} saved as draft.',
-                    'redirect_url': '/my/accessibility/list',
+                    'message': f'Assessment {assessment.reference} saved.',
+                    'redirect_url': redirect_url,
                 }
             
         except Exception as e:

fusion_portal/data/visit_data.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<odoo>
+    <data noupdate="1">
+        <!-- Reference sequence for assessment visits (VISIT/2026/0001) -->
+        <record id="seq_fusion_assessment_visit" model="ir.sequence">
+            <field name="name">Assessment Visit</field>
+            <field name="code">fusion.assessment.visit</field>
+            <field name="prefix">VISIT/%(year)s/</field>
+            <field name="padding">4</field>
+            <field name="company_id" eval="False"/>
+        </record>
+    </data>
+</odoo>

fusion_portal/models/__init__.py

@@ -7,5 +7,6 @@ from . import adp_document
 from . import assessment
 from . import accessibility_assessment
 from . import sale_order
+from . import visit
 from . import loaner_checkout
 from . import pdf_template

fusion_portal/models/accessibility_assessment.py

@@ -73,6 +73,7 @@ class FusionAccessibilityAssessment(models.Model):
             ('march_of_dimes', 'March of Dimes'),
             ('odsp', 'ODSP'),
             ('wsib', 'WSIB'),
+            ('hardship', 'Hardship Funding'),
             ('insurance', 'Private Insurance'),
             ('direct_private', 'Private Pay (Direct)'),
             ('other', 'Other'),
@@ -156,7 +157,14 @@ class FusionAccessibilityAssessment(models.Model):
         readonly=True,
         copy=False,
     )
-    
+    visit_id = fields.Many2one(
+        'fusion.assessment.visit',
+        string='Assessment Visit',
+        ondelete='set null',
+        index=True,
+        help='The home visit this accessibility assessment belongs to.',
+    )
+
     # Dates
     assessment_date = fields.Date(
         string='Assessment Date',
@@ -772,6 +780,7 @@ class FusionAccessibilityAssessment(models.Model):
             'march_of_dimes': 'march_of_dimes',
             'odsp': 'odsp',
             'wsib': 'wsib',
+            'hardship': 'hardship',
             'insurance': 'insurance',
             'direct_private': 'direct_private',
             'other': 'other',

fusion_portal/models/assessment.py

@@ -45,6 +45,7 @@ class FusionAssessment(models.Model):
         ('rollator', 'Rollator'),
         ('wheelchair', 'Wheelchair'),
         ('powerchair', 'Powerchair'),
+        ('scooter', 'Mobility Scooter'),
     ], string='Equipment Type', tracking=True, index=True)
     
     # Rollator Types
@@ -69,6 +70,31 @@ class FusionAssessment(models.Model):
         ('type_2', 'Adult Power Base Type 2'),
         ('type_3', 'Adult Power Base Type 3'),
     ], string='Powerchair Type')
+
+    # ===== MOBILITY SCOOTER (ADP) — 2026-06 Phase 2 =====
+    scooter_type = fields.Selection([
+        ('travel_3', '3-Wheel Travel/Portable'),
+        ('travel_4', '4-Wheel Travel/Portable'),
+        ('standard_3', '3-Wheel Standard'),
+        ('standard_4', '4-Wheel Standard'),
+        ('heavy_duty', 'Heavy-Duty / Bariatric'),
+    ], string='Scooter Type')
+    scooter_max_range = fields.Float(
+        string='Maximum Range Needed (km)', digits=(10, 1),
+        help='Maximum distance the client needs the scooter to travel on a charge.',
+    )
+
+    # ===== POWER-MOBILITY HOME ACCESSIBILITY (ADP hard rule) =====
+    # Applies to scooter + power wheelchair: ADP funds power mobility only if the
+    # device can enter and be used at the residence independently, without lifting.
+    x_fc_power_home_accessible = fields.Selection([
+        ('yes', 'Yes — usable inside and outside independently'),
+        ('no', 'No — home needs accessibility work'),
+    ], string='Home accessible for power-mobility device?',
+        help='ADP will not fund a scooter / power wheelchair if the home cannot '
+             'take it (device left outside or in the garage). If No, the home '
+             'needs an accessibility product (ramp / porch lift).')
+    x_fc_power_home_access_notes = fields.Text(string='Home Access Notes')
     
     # ===== EXPRESS FORM: ROLLATOR MEASUREMENTS =====
     rollator_handle_height = fields.Float(string='Handle Height (inches)', digits=(10, 2))
@@ -425,7 +451,15 @@ class FusionAssessment(models.Model):
         readonly=True,
         copy=False,
     )
-    
+    visit_id = fields.Many2one(
+        'fusion.assessment.visit',
+        string='Assessment Visit',
+        ondelete='set null',
+        index=True,
+        help='The home visit this ADP assessment belongs to (groups multiple '
+             'assessments / funding workflows from one visit).',
+    )
+
     # ===== COMPUTED FIELDS =====
     document_count = fields.Integer(
         string='Document Count',
@@ -1452,20 +1486,18 @@ class FusionAssessment(models.Model):
             })
 
     def _send_completion_notifications(self):
-        """Send email notifications when assessment is completed"""
+        """Notify the CLIENT that the assessment is complete.
+
+        The authorizer, sales rep and office are already emailed (with the full
+        assessment report) by ``_send_assessment_completed_email`` inside
+        ``_create_draft_sale_order``. This method used to ALSO send the
+        authorizer a second, template-only email — that duplicate is removed;
+        here we only notify the client.
+        """
         self.ensure_one()
-        
-        # Send to authorizer
-        if self.authorizer_id and self.authorizer_id.email:
-            try:
-                template = self.env.ref('fusion_portal.mail_template_assessment_complete_authorizer', raise_if_not_found=False)
-                if template:
-                    template.send_mail(self.id, force_send=True)
-                    _logger.info(f"Sent assessment completion email to authorizer {self.authorizer_id.email}")
-            except Exception as e:
-                _logger.error(f"Failed to send authorizer notification: {e}")
-        
-        # Send to client
+
+        # Send to client (authorizer/rep/office already emailed by
+        # _send_assessment_completed_email in _create_draft_sale_order)
         if self.client_email:
             try:
                 template = self.env.ref('fusion_portal.mail_template_assessment_complete_client', raise_if_not_found=False)

fusion_portal/models/sale_order.py

@@ -53,6 +53,17 @@ class SaleOrder(models.Model):
              'sale order — stair lift, VPL, ceiling lift, ramp, bathroom mod, '
              'or tub cutout visits.',
     )
+
+    # Link to the assessment visit (one visit -> one SO per funding workflow).
+    visit_id = fields.Many2one(
+        'fusion.assessment.visit',
+        string='Assessment Visit',
+        readonly=True,
+        index=True,
+        help='The home visit this sale order was generated from. A visit '
+             'produces one sale order per funding workflow (ADP / MOD / ODSP / '
+             'private / ...).',
+    )
     
     # Authorizer helper field (consolidates multiple possible fields)
     portal_authorizer_id = fields.Many2one(

fusion_portal/models/visit.py

@@ -0,0 +1,299 @@
+# -*- coding: utf-8 -*-
+"""Assessment Visit — bundles the assessments done during one home visit.
+
+A sales rep + occupational therapist visit a client for 30-45 min and may do
+several assessments (an ADP wheelchair plus accessibility products like a stair
+lift, ramp, or tub cutout). The Visit is the hub that holds the client/context
+ONCE and, on completion, groups its assessments by FUNDING WORKFLOW
+(x_fc_sale_type) and creates ONE draft sale order per workflow — never one
+combined SO, and never a separate SO per item within the same funding.
+
+See docs/superpowers/specs/2026-06-02-assessment-visit-funding-design.md.
+"""
+import logging
+from markupsafe import Markup
+from odoo import api, fields, models, _
+from odoo.exceptions import UserError
+
+_logger = logging.getLogger(__name__)
+
+# Accessibility funding source -> sale.order x_fc_sale_type. Mirrors
+# fusion.accessibility.assessment._create_draft_sale_order so a grouped Visit
+# routes exactly the way a single accessibility assessment would.
+ACCESSIBILITY_SALE_TYPE_MAP = {
+    'march_of_dimes': 'march_of_dimes',
+    'odsp': 'odsp',
+    'wsib': 'wsib',
+    'hardship': 'hardship',
+    'insurance': 'insurance',
+    'direct_private': 'direct_private',
+    'other': 'other',
+}
+
+
+class FusionAssessmentVisit(models.Model):
+    _name = 'fusion.assessment.visit'
+    _description = 'Assessment Visit'
+    _inherit = ['mail.thread', 'mail.activity.mixin']
+    _order = 'visit_date desc, id desc'
+
+    name = fields.Char(
+        string='Visit Reference', required=True, readonly=True,
+        copy=False, default=lambda self: _('New'),
+    )
+    state = fields.Selection(
+        selection=[
+            ('measuring', 'Measuring'),
+            ('client_pending', 'Client Details Pending'),
+            ('done', 'Completed'),
+            ('cancelled', 'Cancelled'),
+        ],
+        default='measuring', tracking=True, copy=False,
+    )
+
+    # --- Shared client + context (entered once for the whole visit) ---------
+    partner_id = fields.Many2one('res.partner', string='Client', tracking=True)
+    client_name = fields.Char(string='Client Name', tracking=True)
+    client_phone = fields.Char(string='Phone')
+    client_email = fields.Char(string='Email')
+    client_address = fields.Char(string='Address')
+    visit_date = fields.Date(
+        string='Visit Date', default=fields.Date.context_today, tracking=True,
+    )
+    sales_rep_id = fields.Many2one(
+        'res.users', string='Sales Rep',
+        default=lambda self: self.env.user, tracking=True,
+    )
+    authorizer_id = fields.Many2one(
+        'res.partner', string='Occupational Therapist', tracking=True,
+    )
+
+    # --- March of Dimes funding context (informational; spec §4.1) ----------
+    # MOD covers up to $15,000 per person (lifetime), income-gated.
+    x_fc_income_under_mod_threshold = fields.Selection(
+        selection=[
+            ('yes', 'Yes — under threshold (full $15k available)'),
+            ('no', 'No — over threshold (may be denied / partial)'),
+            ('unknown', 'Unknown'),
+        ],
+        string='Income under MOD threshold?', default='unknown',
+        help='March of Dimes funds up to $15,000 per person (lifetime) when the '
+             "client's income is under that year's threshold; over it, MOD may "
+             'deny or partially approve. Reminder only — no automatic cap '
+             'enforcement in this version.',
+    )
+
+    # --- Assessments performed during this visit ----------------------------
+    adp_assessment_ids = fields.One2many(
+        'fusion.assessment', 'visit_id', string='ADP Assessments',
+    )
+    accessibility_assessment_ids = fields.One2many(
+        'fusion.accessibility.assessment', 'visit_id',
+        string='Accessibility Assessments',
+    )
+
+    # --- Sale orders produced — one per funding workflow --------------------
+    sale_order_ids = fields.One2many(
+        'sale.order', 'visit_id', string='Sale Orders',
+    )
+
+    assessment_count = fields.Integer(compute='_compute_counts')
+    sale_order_count = fields.Integer(compute='_compute_counts')
+    has_mod_items = fields.Boolean(compute='_compute_has_mod_items')
+
+    @api.depends('adp_assessment_ids', 'accessibility_assessment_ids', 'sale_order_ids')
+    def _compute_counts(self):
+        for visit in self:
+            visit.assessment_count = (
+                len(visit.adp_assessment_ids)
+                + len(visit.accessibility_assessment_ids)
+            )
+            visit.sale_order_count = len(visit.sale_order_ids)
+
+    @api.depends('accessibility_assessment_ids.x_fc_funding_source')
+    def _compute_has_mod_items(self):
+        for visit in self:
+            visit.has_mod_items = any(
+                a.x_fc_funding_source == 'march_of_dimes'
+                for a in visit.accessibility_assessment_ids
+            )
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        for vals in vals_list:
+            if not vals.get('name') or vals['name'] == _('New'):
+                seq = self.env['ir.sequence'].next_by_code('fusion.assessment.visit')
+                vals['name'] = seq or _('New')
+        return super().create(vals_list)
+
+    # ------------------------------------------------------------------
+    # Completion — group assessments by funding workflow → one SO each
+    # ------------------------------------------------------------------
+    def _ensure_partner(self):
+        """Resolve the client partner for the visit, reusing an assessment's
+        partner/_ensure_partner when one is already set."""
+        self.ensure_one()
+        if self.partner_id:
+            return self.partner_id
+        # Borrow a child assessment's partner resolution if available.
+        for assessment in self.accessibility_assessment_ids:
+            if assessment.partner_id:
+                return assessment.partner_id
+            if hasattr(assessment, '_ensure_partner'):
+                return assessment._ensure_partner()
+        for assessment in self.adp_assessment_ids:
+            if assessment.partner_id:
+                return assessment.partner_id
+        if self.client_name:
+            return self.env['res.partner'].sudo().create({
+                'name': self.client_name,
+                'phone': self.client_phone or False,
+                'email': self.client_email or False,
+            })
+        raise UserError(_('Set a client (or client name) on the visit first.'))
+
+    def _create_grouped_sale_order(self, partner, sale_type, accessibility_assessments):
+        """Create ONE draft sale order for a set of same-funding accessibility
+        assessments, link them all to it, and post each one's spec to chatter.
+        Mirrors fusion.accessibility.assessment._create_draft_sale_order but for
+        a group sharing one funding workflow."""
+        self.ensure_one()
+        SaleOrder = self.env['sale.order'].sudo()
+
+        so_vals = {
+            'partner_id': partner.id,
+            'user_id': self.sales_rep_id.id if self.sales_rep_id else self.env.user.id,
+            'state': 'draft',
+            'origin': _('Visit %s (%s)') % (self.name, sale_type),
+            'x_fc_sale_type': sale_type,
+            'visit_id': self.id,
+        }
+        if self.authorizer_id:
+            so_vals['x_fc_authorizer_id'] = self.authorizer_id.id
+        # MOD: pre-fill the accessibility specialist from the sales rep.
+        if sale_type == 'march_of_dimes' and self.sales_rep_id and self.sales_rep_id.partner_id:
+            so_vals['x_fc_mod_accessibility_specialist_id'] = self.sales_rep_id.partner_id.id
+
+        sale_order = SaleOrder.create(so_vals)
+        for assessment in accessibility_assessments:
+            assessment.sale_order_id = sale_order.id
+            assessment._add_assessment_tag(sale_order)
+            sale_order.message_post(
+                body=Markup(assessment._format_assessment_html_table()),
+                message_type='comment',
+                subtype_xmlid='mail.mt_note',
+            )
+            assessment.write({'state': 'completed'})
+        # One completion notification per SO (not per assessment) — mirrors the
+        # standalone accessibility completion's office email.
+        if accessibility_assessments:
+            try:
+                accessibility_assessments[0]._send_completion_email(sale_order)
+            except Exception as e:
+                _logger.warning(
+                    "Visit %s: completion email failed for %s: %s",
+                    self.name, sale_order.name, e,
+                )
+        _logger.info(
+            "Visit %s created %s sale order %s grouping %d accessibility assessment(s)",
+            self.name, sale_type, sale_order.name, len(accessibility_assessments),
+        )
+        return sale_order
+
+    def _validate_adp_combination(self, adp_assessments):
+        """Enforce ADP device-combination rules: at most one seated-mobility
+        device (manual wheelchair / power wheelchair / scooter), optionally one
+        walker/rollator, no duplicates."""
+        seated_types = {'wheelchair', 'powerchair', 'scooter'}
+        seated = [a for a in adp_assessments if a.equipment_type in seated_types]
+        walkers = [a for a in adp_assessments if a.equipment_type == 'rollator']
+        labels = dict(self.env['fusion.assessment']._fields['equipment_type'].selection)
+        if len(seated) > 1:
+            raise UserError(_(
+                'An ADP order can include only one seated-mobility device '
+                '(manual wheelchair, power wheelchair, or scooter). This visit has: %s.'
+            ) % ', '.join(labels.get(a.equipment_type, a.equipment_type) for a in seated))
+        if len(walkers) > 1:
+            raise UserError(_('An ADP order can include only one walker / rollator.'))
+
+    def _assessment_sale_type(self, adp_assessment):
+        """Funding workflow key for an ADP equipment assessment, mirroring
+        fusion.assessment._create_draft_sale_order: ADP+ODSP when the client
+        type is an ODSP stream, plain ADP otherwise. ADP devices that share a
+        key are grouped onto one sale order."""
+        if adp_assessment.client_type in ('ods', 'acs', 'owp'):
+            return 'adp_odsp'
+        return 'adp'
+
+    def action_complete_visit(self):
+        """Group the visit's accessibility assessments by funding workflow and
+        create one draft SO per workflow. ADP equipment assessments keep their
+        existing one-assessment-one-SO completion for now (ADP multi-device
+        grouping arrives in Phase 2)."""
+        self.ensure_one()
+        if self.state == 'done':
+            raise UserError(_('This visit is already completed.'))
+        if not (self.accessibility_assessment_ids or self.adp_assessment_ids):
+            raise UserError(_('Add at least one assessment before completing the visit.'))
+
+        partner = self._ensure_partner()
+
+        # Group accessibility assessments by their funding -> sale type.
+        by_sale_type = {}
+        for assessment in self.accessibility_assessment_ids:
+            if assessment.sale_order_id:
+                continue  # already has an SO; don't duplicate
+            sale_type = ACCESSIBILITY_SALE_TYPE_MAP.get(
+                assessment.x_fc_funding_source, 'direct_private')
+            by_sale_type.setdefault(sale_type, []).append(assessment)
+
+        for sale_type, group in by_sale_type.items():
+            self._create_grouped_sale_order(partner, sale_type, group)
+
+        # ADP equipment assessments: one ADP order per funding type, with the
+        # device-combination guard, reusing the existing (prod-tested) express
+        # completion. The first device creates the SO; the rest attach to it.
+        adp_by_type = {}
+        for assessment in self.adp_assessment_ids:
+            if assessment.sale_order_id:
+                continue
+            adp_by_type.setdefault(self._assessment_sale_type(assessment), []).append(assessment)
+        labels = dict(self.env['fusion.assessment']._fields['equipment_type'].selection)
+        for sale_type, group in adp_by_type.items():
+            self._validate_adp_combination(group)
+            # Make sure each device carries the visit's client + OT so the
+            # existing completion logic has what it needs.
+            for assessment in group:
+                vals = {}
+                if not assessment.client_name:
+                    vals['client_name'] = self.client_name or partner.name
+                if not assessment.authorizer_id and self.authorizer_id:
+                    vals['authorizer_id'] = self.authorizer_id.id
+                if not assessment.partner_id:
+                    vals['partner_id'] = partner.id
+                if vals:
+                    assessment.write(vals)
+            primary = group[0]
+            sale_order = primary.action_complete_express()
+            sale_order.write({'visit_id': self.id, 'x_fc_sale_type': sale_type})
+            for extra in group[1:]:
+                extra.write({'state': 'completed', 'sale_order_id': sale_order.id})
+                sale_order.message_post(
+                    body=Markup('<p><strong>Additional ADP device on this order:</strong> %s</p>')
+                    % labels.get(extra.equipment_type, extra.equipment_type or 'device'),
+                    subtype_xmlid='mail.mt_note',
+                )
+
+        self.write({'state': 'done', 'partner_id': partner.id})
+        return self._action_view_sale_orders()
+
+    def _action_view_sale_orders(self):
+        self.ensure_one()
+        return {
+            'type': 'ir.actions.act_window',
+            'name': _('Visit Sale Orders'),
+            'res_model': 'sale.order',
+            'view_mode': 'list,form',
+            'domain': [('visit_id', '=', self.id)],
+            'context': {'create': False},
+        }

fusion_portal/security/ir.model.access.csv

@@ -7,6 +7,8 @@ access_fusion_assessment_user,fusion.assessment.user,model_fusion_assessment,bas
 access_fusion_assessment_portal,fusion.assessment.portal,model_fusion_assessment,base.group_portal,1,1,1,0
 access_fusion_accessibility_assessment_user,fusion.accessibility.assessment.user,model_fusion_accessibility_assessment,base.group_user,1,1,1,1
 access_fusion_accessibility_assessment_portal,fusion.accessibility.assessment.portal,model_fusion_accessibility_assessment,base.group_portal,1,1,1,0
+access_fusion_assessment_visit_user,fusion.assessment.visit.user,model_fusion_assessment_visit,base.group_user,1,1,1,1
+access_fusion_assessment_visit_portal,fusion.assessment.visit.portal,model_fusion_assessment_visit,base.group_portal,1,1,1,0
 access_fusion_pdf_template_user,fusion.pdf.template.user,model_fusion_pdf_template,base.group_user,1,1,1,1
 access_fusion_pdf_template_preview_user,fusion.pdf.template.preview.user,model_fusion_pdf_template_preview,base.group_user,1,1,1,1
 access_fusion_pdf_template_field_user,fusion.pdf.template.field.user,model_fusion_pdf_template_field,base.group_user,1,1,1,1

fusion_portal/static/src/css/portal_style.css

@@ -448,6 +448,42 @@
     font-size: 1.25rem;
 }
 
+/* Start a Visit Card on Portal Home (distinct blue->indigo so it differs from
+   the green New Assessment tile). Mirrors .portal-new-assessment-card. */
+.portal-visit-card {
+    background: linear-gradient(135deg, #2e7aad 0%, #4338ca 100%) !important;
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+
+.portal-visit-card:hover {
+    transform: translateY(-5px);
+    box-shadow: 0 10px 30px rgba(67, 56, 202, 0.3) !important;
+}
+
+.portal-visit-card .card-body {
+    background: transparent !important;
+}
+
+.portal-visit-card h5,
+.portal-visit-card small {
+    color: #fff !important;
+}
+
+.portal-visit-card .icon-circle {
+    width: 50px;
+    height: 50px;
+    background: rgba(255,255,255,0.25) !important;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.portal-visit-card .icon-circle i {
+    color: #fff !important;
+    font-size: 1.25rem;
+}
+
 /* Authorizer Portal Card on Portal Home */
 .portal-authorizer-card {
     background: var(--fc-portal-gradient, linear-gradient(135deg, #5ba848 0%, #3a8fb7 60%, #2e7aad 100%)) !important;

fusion_portal/views/portal_accessibility_templates.xml

@@ -373,6 +373,22 @@
                         <input type="email" name="client_email" class="form-control" placeholder="email@example.com"/>
                     </div>
                 </div>
+                <div class="row">
+                    <div class="col-md-6 mb-3">
+                        <label class="form-label">Funding Source <span class="text-danger">*</span></label>
+                        <select name="funding_source" class="form-select" required="required">
+                            <option value="direct_private" selected="selected">Private Pay (Direct)</option>
+                            <option value="march_of_dimes">March of Dimes</option>
+                            <option value="odsp">ODSP</option>
+                            <option value="wsib">WSIB</option>
+                            <option value="hardship">Hardship Funding</option>
+                            <option value="insurance">Private Insurance</option>
+                            <option value="other">Other</option>
+                        </select>
+                        <small class="text-muted">Determines which sale order / funding workflow this case enters.</small>
+                    </div>
+                </div>
+                <input type="hidden" name="visit_id" id="acc_visit_id"/>
             </div>
         </div>
     </template>
@@ -632,6 +648,15 @@
             // Fallback if Google Maps not loaded
             window.initAddressAutocomplete = window.initAddressAutocomplete || function() {};
             
+            // Carry visit_id from the workspace launch (?visit_id=) into the form
+            (function() {
+                var _vid = new URLSearchParams(window.location.search).get('visit_id');
+                if (_vid) {
+                    var f = document.getElementById('acc_visit_id');
+                    if (f) { f.value = _vid; }
+                }
+            })();
+
             // Form submission
             function saveAssessment(createSaleOrder) {
                 var form = document.getElementById('accessibility_form');

fusion_portal/views/portal_assessment_express.xml

@@ -85,7 +85,19 @@
                     <input type="hidden" name="csrf_token" t-att-value="request.csrf_token()"/>
                     <input type="hidden" name="assessment_id" t-att-value="assessment.id if assessment else ''"/>
                     <input type="hidden" name="current_page" value="1"/>
-                    
+                    <input type="hidden" name="visit_id" id="express_visit_id" t-att-value="visit_id or ''"/>
+
+                    <!-- Part of an assessment visit: completing returns to the visit, which groups
+                         this device with the rest into one funding-routed ADP order. -->
+                    <div t-if="visit_id" class="alert alert-info d-flex align-items-start gap-2 mb-3">
+                        <i class="fa fa-clipboard mt-1"/>
+                        <div>
+                            <strong>Part of an assessment visit.</strong>
+                            Completing this device returns you to the visit — it is grouped with the
+                            visit's other ADP devices into a single sale order when you complete the visit.
+                        </div>
+                    </div>
+
                     <!-- Equipment Selection Section -->
                     <div class="card shadow-sm">
                         <div class="card-body">
@@ -98,6 +110,7 @@
                                     <option value="rollator" t-att-selected="assessment.equipment_type == 'rollator' if assessment else False">Rollator</option>
                                     <option value="wheelchair" t-att-selected="assessment.equipment_type == 'wheelchair' if assessment else False">Wheelchair</option>
                                     <option value="powerchair" t-att-selected="assessment.equipment_type == 'powerchair' if assessment else False">Powerchair</option>
+                                    <option value="scooter" t-att-selected="assessment.equipment_type == 'scooter' if assessment else False">Mobility Scooter</option>
                                 </select>
                             </div>
                             
@@ -688,8 +701,62 @@
                                     <label class="form-label fw-bold">Additional Information/Customization</label>
                                     <textarea name="additional_customization" class="form-control powerchair-field" rows="4" placeholder="Enter any additional requirements or customization notes..."><t t-esc="assessment.additional_customization if assessment else ''"/></textarea>
                                 </div>
+
+                                <!-- Power-mobility home-accessibility — ADP hard rule -->
+                                <div class="mb-4 p-3 border rounded bg-light">
+                                    <label class="form-label fw-bold">Home accessible for the device — inside &amp; outside?</label>
+                                    <select name="x_fc_power_home_accessible" class="form-control">
+                                        <option value="">-- Select --</option>
+                                        <option value="yes" t-att-selected="assessment.x_fc_power_home_accessible == 'yes' if assessment else False">Yes — usable inside and outside independently</option>
+                                        <option value="no" t-att-selected="assessment.x_fc_power_home_accessible == 'no' if assessment else False">No — home needs accessibility work</option>
+                                    </select>
+                                    <div class="alert alert-warning mt-2 mb-0">
+                                        <i class="fa fa-exclamation-triangle"/> ADP funds power mobility only if the device can enter and be used at the residence <strong>independently, without lifting</strong> (not left outside / in the garage). If <strong>No</strong>, add an accessibility assessment (ramp / porch lift) for the home.
+                                    </div>
+                                    <textarea name="x_fc_power_home_access_notes" class="form-control mt-2" rows="2" placeholder="Access notes (entry steps, garage, thresholds, turning space...)"><t t-esc="assessment.x_fc_power_home_access_notes if assessment else ''"/></textarea>
+                                </div>
                             </div>
-                            
+
+                            <!-- ===== MOBILITY SCOOTER ===== -->
+                            <div id="scooter_form" class="equipment-form" style="display: none;">
+                                <h2 class="text-center fw-bold text-uppercase mb-4">Mobility Scooter Assessment</h2>
+                                <div class="mb-4">
+                                    <label class="form-label fw-bold">Scooter Type</label>
+                                    <select name="scooter_type" class="form-select">
+                                        <option value="">-- Select Type --</option>
+                                        <option value="travel_3" t-att-selected="assessment.scooter_type == 'travel_3' if assessment else False">3-Wheel Travel/Portable</option>
+                                        <option value="travel_4" t-att-selected="assessment.scooter_type == 'travel_4' if assessment else False">4-Wheel Travel/Portable</option>
+                                        <option value="standard_3" t-att-selected="assessment.scooter_type == 'standard_3' if assessment else False">3-Wheel Standard</option>
+                                        <option value="standard_4" t-att-selected="assessment.scooter_type == 'standard_4' if assessment else False">4-Wheel Standard</option>
+                                        <option value="heavy_duty" t-att-selected="assessment.scooter_type == 'heavy_duty' if assessment else False">Heavy-Duty / Bariatric</option>
+                                    </select>
+                                </div>
+                                <div class="row mb-3">
+                                    <div class="col-12 col-md-6 mb-3">
+                                        <label class="form-label fw-bold">Maximum Range Needed (km)</label>
+                                        <div class="input-group">
+                                            <input type="number" step="1" name="scooter_max_range" class="form-control"
+                                                   t-att-value="assessment.scooter_max_range if assessment else ''"/>
+                                            <span class="input-group-text">km</span>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <!-- Power-mobility home-accessibility — ADP hard rule -->
+                                <div class="mb-4 p-3 border rounded bg-light">
+                                    <label class="form-label fw-bold">Home accessible for the device — inside &amp; outside?</label>
+                                    <select name="x_fc_power_home_accessible" class="form-control">
+                                        <option value="">-- Select --</option>
+                                        <option value="yes" t-att-selected="assessment.x_fc_power_home_accessible == 'yes' if assessment else False">Yes — usable inside and outside independently</option>
+                                        <option value="no" t-att-selected="assessment.x_fc_power_home_accessible == 'no' if assessment else False">No — home needs accessibility work</option>
+                                    </select>
+                                    <div class="alert alert-warning mt-2 mb-0">
+                                        <i class="fa fa-exclamation-triangle"/> ADP funds power mobility only if the device can enter and be used at the residence <strong>independently, without lifting</strong> (not left outside / in the garage). If <strong>No</strong>, add an accessibility assessment (ramp / porch lift) for the home.
+                                    </div>
+                                    <textarea name="x_fc_power_home_access_notes" class="form-control mt-2" rows="2" placeholder="Access notes (entry steps, garage, thresholds, turning space...)"><t t-esc="assessment.x_fc_power_home_access_notes if assessment else ''"/></textarea>
+                                </div>
+                            </div>
+
                         </div>
                     </div>
                     
@@ -1191,9 +1258,10 @@
                     <div class="card shadow-sm">
                         <div class="card-body text-center">
                             <button type="submit" name="action" value="submit" class="btn btn-success btn-lg px-5">
-                                <i class="fa fa-check me-2"/>Submit Assessment
+                                <t t-if="visit_id"><i class="fa fa-clipboard me-2"/>Save to Visit</t>
+                                <t t-else=""><i class="fa fa-check me-2"/>Submit Assessment</t>
                             </button>
-                            <a href="/my/assessments" class="btn btn-outline-secondary btn-lg px-4 ms-3">
+                            <a t-att-href="('/my/visit/%s' % visit_id) if visit_id else '/my/assessments'" class="btn btn-outline-secondary btn-lg px-4 ms-3">
                                 Cancel
                             </a>
                         </div>
@@ -1278,6 +1346,7 @@
                     var rollatorForm = document.getElementById('rollator_form');
                     var wheelchairForm = document.getElementById('wheelchair_form');
                     var powerchairForm = document.getElementById('powerchair_form');
+                    var scooterForm = document.getElementById('scooter_form');
                     var wheelchairTypeSelect = document.querySelector('select[name="wheelchair_type"]');
                     var reasonSelect = document.getElementById('reason_for_application');
                     var previousFundingContainer = document.getElementById('previous_funding_date_container');
@@ -1339,13 +1408,16 @@
                         disableFormInputs(rollatorForm);
                         disableFormInputs(wheelchairForm);
                         disableFormInputs(powerchairForm);
-                        
+                        disableFormInputs(scooterForm);
+
                         if (value === 'rollator') {
                             enableFormInputs(rollatorForm);
                         } else if (value === 'wheelchair') {
                             enableFormInputs(wheelchairForm);
                         } else if (value === 'powerchair') {
                             enableFormInputs(powerchairForm);
+                        } else if (value === 'scooter') {
+                            enableFormInputs(scooterForm);
                         }
                     }
                     

fusion_portal/views/portal_templates.xml

@@ -50,6 +50,25 @@
                 
                 <!-- Main Action Tiles - Professional Grid Layout -->
                 <div class="row g-3 mb-4">
+                    <!-- 0. Start a Visit (Sales Rep) - bundle multiple assessments from one home visit -->
+                    <t t-if="request.env.user.partner_id.is_sales_rep_portal">
+                        <div class="col-md-6">
+                            <a href="/my/visit/new" class="card h-100 border-0 shadow-sm text-decoration-none portal-visit-card" style="border-radius: 12px; min-height: 100px;">
+                                <div class="card-body d-flex align-items-center p-4">
+                                    <div class="me-3">
+                                        <div class="icon-circle">
+                                            <i class="fa fa-clipboard"/>
+                                        </div>
+                                    </div>
+                                    <div>
+                                        <h5 class="mb-1">Start a Visit</h5>
+                                        <small>Bundle several assessments from one home visit into funding-routed orders</small>
+                                    </div>
+                                </div>
+                            </a>
+                        </div>
+                    </t>
+
                     <!-- 1. New Express Assessment (Sales Rep) - Featured tile -->
                     <t t-if="request.env.user.partner_id.is_sales_rep_portal">
                         <div class="col-md-6">

fusion_portal/views/portal_visit.xml

@@ -0,0 +1,115 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+    <template id="portal_visit_workspace" name="Assessment Visit Workspace">
+        <t t-call="portal.portal_layout">
+            <t t-set="no_breadcrumbs" t-value="True"/>
+            <div class="container py-4">
+                <nav aria-label="breadcrumb" class="mb-3">
+                    <ol class="breadcrumb">
+                        <li class="breadcrumb-item"><a href="/my">Dashboard</a></li>
+                        <li class="breadcrumb-item active">Assessment Visit</li>
+                    </ol>
+                </nav>
+
+                <t t-if="error">
+                    <div class="alert alert-danger"><i class="fa fa-exclamation-circle"/> <t t-esc="error"/></div>
+                </t>
+
+                <div class="d-flex justify-content-between align-items-center mb-3">
+                    <h3 class="mb-0"><i class="fa fa-clipboard text-primary"/> Visit <t t-esc="visit.name"/></h3>
+                    <span class="badge bg-secondary"><span t-field="visit.state"/></span>
+                </div>
+
+                <t t-if="visit.state == 'done'">
+                    <div class="alert alert-success">
+                        <strong>Visit completed.</strong> Sale orders created:
+                        <ul class="mb-0">
+                            <t t-foreach="visit.sale_order_ids" t-as="so">
+                                <li><a t-attf-href="/my/sales/case/{{so.id}}"><t t-esc="so.name"/></a> — <span t-field="so.x_fc_sale_type"/></li>
+                            </t>
+                        </ul>
+                    </div>
+                </t>
+
+                <!-- Assessments added this visit -->
+                <div class="card border-0 shadow-sm mb-4">
+                    <div class="card-header bg-white"><strong>Assessments this visit</strong> (<t t-esc="visit.assessment_count"/>)</div>
+                    <div class="card-body">
+                        <p t-if="not visit.assessment_count" class="text-muted mb-0">
+                            Nothing added yet — use the buttons below to add what you're assessing.
+                        </p>
+                        <ul class="list-group" t-if="visit.assessment_count">
+                            <t t-foreach="visit.adp_assessment_ids" t-as="a">
+                                <li class="list-group-item d-flex justify-content-between align-items-center">
+                                    <span><i class="fa fa-wheelchair text-primary"/> ADP — <span t-field="a.equipment_type"/></span>
+                                    <span class="badge bg-light text-dark"><span t-field="a.state"/></span>
+                                </li>
+                            </t>
+                            <t t-foreach="visit.accessibility_assessment_ids" t-as="a">
+                                <li class="list-group-item d-flex justify-content-between align-items-center">
+                                    <span><span t-field="a.assessment_type"/> — <span t-field="a.x_fc_funding_source"/></span>
+                                    <span class="badge bg-light text-dark"><span t-field="a.state"/></span>
+                                </li>
+                            </t>
+                        </ul>
+                    </div>
+                </div>
+
+                <t t-if="visit.state != 'done'">
+                    <!-- Add assessment -->
+                    <div class="card border-0 shadow-sm mb-4">
+                        <div class="card-header bg-white"><strong>+ Add assessment</strong></div>
+                        <div class="card-body d-flex flex-wrap gap-2">
+                            <a class="btn btn-outline-primary" t-attf-href="/my/assessment/express?visit_id={{visit.id}}">Wheelchair / ADP</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/stairlift/straight?visit_id={{visit.id}}">Straight Stair Lift</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/stairlift/curved?visit_id={{visit.id}}">Curved Stair Lift</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/vpl?visit_id={{visit.id}}">Platform / Porch Lift</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/ceiling-lift?visit_id={{visit.id}}">Ceiling Lift</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/ramp?visit_id={{visit.id}}">Custom Ramp</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/bathroom?visit_id={{visit.id}}">Bathroom Mod</a>
+                            <a class="btn btn-outline-primary" t-attf-href="/my/accessibility/tub-cutout?visit_id={{visit.id}}">Tub Cutout</a>
+                        </div>
+                    </div>
+
+                    <!-- Client details (deferred) -->
+                    <div class="card border-0 shadow-sm mb-4">
+                        <div class="card-header bg-white"><strong>Client details</strong>
+                            <span class="text-muted small">— fill in after the therapist leaves</span></div>
+                        <div class="card-body">
+                            <form t-attf-action="/my/visit/{{visit.id}}/save" method="post">
+                                <input type="hidden" name="csrf_token" t-att-value="request.csrf_token()"/>
+                                <div class="row">
+                                    <div class="col-md-6 mb-3"><label class="form-label">Client Name</label>
+                                        <input type="text" name="client_name" class="form-control" t-att-value="visit.client_name"/></div>
+                                    <div class="col-md-6 mb-3"><label class="form-label">Phone</label>
+                                        <input type="text" name="client_phone" class="form-control" t-att-value="visit.client_phone"/></div>
+                                    <div class="col-md-6 mb-3"><label class="form-label">Email</label>
+                                        <input type="email" name="client_email" class="form-control" t-att-value="visit.client_email"/></div>
+                                    <div class="col-md-6 mb-3"><label class="form-label">Address</label>
+                                        <input type="text" name="client_address" class="form-control" t-att-value="visit.client_address"/></div>
+                                </div>
+                                <div class="mb-3" t-if="visit.has_mod_items">
+                                    <label class="form-label">Income under March of Dimes threshold?
+                                        <span class="text-muted small">(MOD covers up to $15k/person, lifetime)</span></label>
+                                    <select name="x_fc_income_under_mod_threshold" class="form-select">
+                                        <option value="unknown" t-att-selected="visit.x_fc_income_under_mod_threshold == 'unknown'">Unknown</option>
+                                        <option value="yes" t-att-selected="visit.x_fc_income_under_mod_threshold == 'yes'">Yes — under threshold (full $15k)</option>
+                                        <option value="no" t-att-selected="visit.x_fc_income_under_mod_threshold == 'no'">No — over threshold (may be denied/partial)</option>
+                                    </select>
+                                </div>
+                                <button type="submit" class="btn btn-secondary">Save client details</button>
+                            </form>
+                        </div>
+                    </div>
+
+                    <!-- Complete -->
+                    <form t-attf-action="/my/visit/{{visit.id}}/complete" method="post" t-if="visit.assessment_count">
+                        <input type="hidden" name="csrf_token" t-att-value="request.csrf_token()"/>
+                        <button type="submit" class="btn btn-primary btn-lg">Complete visit &amp; create sale orders &#8594;</button>
+                        <p class="text-muted small mt-2">Creates one sale order per funding workflow (ADP / March of Dimes / private / ...).</p>
+                    </form>
+                </t>
+            </div>
+        </t>
+    </template>
+</odoo>

fusion_portal/views/visit_views.xml

@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="utf-8"?>
+<odoo>
+    <!-- Form -->
+    <record id="view_fusion_assessment_visit_form" model="ir.ui.view">
+        <field name="name">fusion.assessment.visit.form</field>
+        <field name="model">fusion.assessment.visit</field>
+        <field name="arch" type="xml">
+            <form>
+                <header>
+                    <button name="action_complete_visit" type="object"
+                            string="Complete Visit &amp; Create Sale Orders"
+                            class="btn-primary" invisible="state == 'done'"/>
+                    <field name="state" widget="statusbar"
+                           statusbar_visible="measuring,client_pending,done"/>
+                </header>
+                <sheet>
+                    <div class="oe_title">
+                        <h1><field name="name" readonly="1"/></h1>
+                    </div>
+                    <group>
+                        <group string="Client">
+                            <field name="partner_id"/>
+                            <field name="client_name"/>
+                            <field name="client_phone"/>
+                            <field name="client_email"/>
+                        </group>
+                        <group string="Visit">
+                            <field name="visit_date"/>
+                            <field name="sales_rep_id"/>
+                            <field name="authorizer_id"/>
+                            <field name="has_mod_items" invisible="1"/>
+                            <field name="x_fc_income_under_mod_threshold"
+                                   invisible="not has_mod_items"/>
+                        </group>
+                    </group>
+                    <div class="alert alert-info" role="alert" invisible="not has_mod_items">
+                        <strong>March of Dimes:</strong> covers up to $15,000 per person
+                        (lifetime), income-gated. Confirm the client's income status above.
+                    </div>
+                    <notebook>
+                        <page string="Accessibility Assessments">
+                            <field name="accessibility_assessment_ids" readonly="1">
+                                <list>
+                                    <field name="reference"/>
+                                    <field name="assessment_type"/>
+                                    <field name="x_fc_funding_source"/>
+                                    <field name="state"/>
+                                    <field name="sale_order_id"/>
+                                </list>
+                            </field>
+                        </page>
+                        <page string="ADP Assessments">
+                            <field name="adp_assessment_ids" readonly="1">
+                                <list>
+                                    <field name="equipment_type"/>
+                                    <field name="state"/>
+                                    <field name="sale_order_id"/>
+                                </list>
+                            </field>
+                        </page>
+                        <page string="Sale Orders">
+                            <field name="sale_order_ids" readonly="1">
+                                <list>
+                                    <field name="name"/>
+                                    <field name="x_fc_sale_type"/>
+                                    <field name="state"/>
+                                    <field name="amount_total"/>
+                                </list>
+                            </field>
+                        </page>
+                    </notebook>
+                </sheet>
+                <chatter/>
+            </form>
+        </field>
+    </record>
+
+    <!-- List -->
+    <record id="view_fusion_assessment_visit_list" model="ir.ui.view">
+        <field name="name">fusion.assessment.visit.list</field>
+        <field name="model">fusion.assessment.visit</field>
+        <field name="arch" type="xml">
+            <list>
+                <field name="name"/>
+                <field name="visit_date"/>
+                <field name="partner_id"/>
+                <field name="client_name"/>
+                <field name="sales_rep_id"/>
+                <field name="assessment_count"/>
+                <field name="sale_order_count"/>
+                <field name="state"/>
+            </list>
+        </field>
+    </record>
+
+    <!-- Action + menu -->
+    <record id="action_fusion_assessment_visit" model="ir.actions.act_window">
+        <field name="name">Assessment Visits</field>
+        <field name="res_model">fusion.assessment.visit</field>
+        <field name="view_mode">list,form</field>
+    </record>
+
+    <menuitem id="menu_fusion_assessment_visit"
+              name="Assessment Visits"
+              parent="sale.sale_menu_root"
+              action="action_fusion_assessment_visit"
+              sequence="50"/>
+</odoo>

fusion_repairs/__manifest__.py

@@ -4,7 +4,7 @@
 
 {
     'name': 'Fusion Repairs',
-    'version': '19.0.2.2.6',
+    'version': '19.0.2.3.0',
     'category': 'Inventory/Repairs',
     'summary': 'Guided medical equipment repair intake, dispatch, maintenance, and self-service portal',
     'description': """

fusion_repairs/data/mail_template_data.xml

@@ -125,8 +125,8 @@
             We would love to hear how it went - your feedback helps other clients
             find us and helps us improve.
         </p>
-        <!-- H4: URL-encode the company name so the fallback URL survives ampersands + spaces. -->
-        <t t-set="review_url" t-value="object.company_id.x_fc_google_review_url or ('https://www.google.com/search?' + url_encode({'q': object.company_id.name or ''}))"/>
+        <!-- H4: build a fallback search URL without url_encode (not available in the mail QWeb render context); replace spaces so the URL survives. -->
+        <t t-set="review_url" t-value="object.company_id.x_fc_google_review_url or ('https://www.google.com/search?q=' + (object.company_id.name or '').replace(' ', '+'))"/>
         <div style="text-align:center;margin:0 0 24px 0;">
             <a t-att-href="review_url"
                style="display:inline-block;padding:14px 28px;background-color:#38a169;color:#ffffff;text-decoration:none;border-radius:6px;font-size:16px;font-weight:600;">
@@ -433,6 +433,12 @@
             is due for its next scheduled maintenance visit on
             <strong><t t-out="object.next_due_date" t-options="{'widget': 'date'}"/></strong>.
         </p>
+        <div t-if="object.x_fc_maintenance_fee" style="border-left:3px solid #38a169;padding:12px 16px;margin:0 0 24px 0;">
+            <p style="margin:0;font-size:14px;line-height:1.5;">
+                Maintenance visit fee:
+                <strong><t t-out="object.x_fc_maintenance_fee" t-options="{'widget': 'monetary', 'display_currency': object.currency_id}"/></strong><span style="opacity:0.6;"> + applicable tax</span>.
+            </p>
+        </div>
         <div style="text-align:center;margin:0 0 24px 0;">
             <a t-attf-href="/repairs/maintenance/book/{{ object.booking_token }}"
                style="display:inline-block;padding:14px 28px;background-color:#38a169;color:#ffffff;text-decoration:none;border-radius:6px;font-size:16px;font-weight:600;">

fusion_repairs/models/maintenance_contract.py

@@ -80,6 +80,26 @@ class FusionRepairMaintenanceContract(models.Model):
         'res.company', default=lambda self: self.env.company,
     )
 
+    currency_id = fields.Many2one(
+        'res.currency', default=lambda self: self.env.company.currency_id,
+    )
+    x_fc_maintenance_fee = fields.Monetary(
+        string='Maintenance Fee', currency_field='currency_id',
+        help='Flat fee shown to the client for this maintenance visit.',
+    )
+    x_fc_source = fields.Selection(
+        [('sale', 'New Sale'), ('backfill', 'Backfill'),
+         ('claims', 'Claims Bridge'), ('manual', 'Manual')],
+        string='Source', default='manual', index=True,
+    )
+    x_fc_source_sale_line_id = fields.Many2one(
+        'sale.order.line', string='Source Sale Line', index=True, copy=False,
+    )
+    x_fc_device_serial = fields.Char(string='Serial (text)', index=True, copy=False)
+    x_fc_policy_category_id = fields.Many2one(
+        'fusion.repair.product.category', string='Maintenance Policy',
+    )
+
     _booking_token_unique = models.Constraint(
         'unique(booking_token)',
         'Booking token must be unique.',
@@ -195,11 +215,18 @@ class FusionRepairMaintenanceContract(models.Model):
 class SaleOrder(models.Model):
     _inherit = 'sale.order'
 
+    def _fc_maintenance_anchor_date(self, line):
+        """Best-available delivery anchor: commitment_date -> date_order -> today.
+        (Non-ADP / lift units lack a delivery date; this fallback chain handles them.)"""
+        so = line.order_id
+        anchor = so.commitment_date or so.date_order
+        return fields.Date.to_date(anchor) if anchor else fields.Date.context_today(self)
+
     def _spawn_maintenance_contracts(self):
-        """Create maintenance contracts for any delivered SO line whose
-        product has x_fc_maintenance_interval_months > 0."""
+        """Create a priced maintenance contract per maintainable unit on a confirmed SO.
+        Policy = product interval override, else the product's category policy.
+        Idempotent: by serial when captured, else by source sale line."""
         Contract = self.env['fusion.repair.maintenance.contract'].sudo()
-        today = fields.Date.context_today(self)
         for so in self:
             if so.state not in ('sale', 'done'):
                 continue
@@ -207,21 +234,42 @@ class SaleOrder(models.Model):
                 product = line.product_id
                 if not product:
                     continue
-                interval = product.product_tmpl_id.x_fc_maintenance_interval_months or 0
-                if interval <= 0:
+                tmpl = product.product_tmpl_id
+                category = tmpl.x_fc_repair_category_id
+                product_interval = tmpl.x_fc_maintenance_interval_months or 0
+                cat_enabled = bool(category) and category.x_fc_maintenance_enabled
+                interval = product_interval or (
+                    category.x_fc_maintenance_interval_months if cat_enabled else 0)
+                if interval <= 0 or not (product_interval > 0 or cat_enabled):
                     continue
-                existing = Contract.search([
-                    ('partner_id', '=', so.partner_id.id),
-                    ('product_id', '=', product.id),
-                    ('original_sale_order_id', '=', so.id),
-                ], limit=1)
-                if existing:
+                fee = tmpl.x_fc_maintenance_fee or (
+                    category.x_fc_maintenance_fee if category else 0.0)
+                # Capture serial only if fusion_claims' line field is present.
+                serial = ''
+                if 'x_fc_serial_number' in line._fields:
+                    serial = (line.x_fc_serial_number or '').strip()
+                # Idempotency: serial regime vs source-line regime (spec 6.2).
+                if serial:
+                    dedup = [('state', '=', 'active'), ('x_fc_device_serial', '=', serial)]
+                else:
+                    dedup = [('state', '=', 'active'),
+                             ('x_fc_source_sale_line_id', '=', line.id)]
+                if Contract.search_count(dedup):
                     continue
-                Contract.create({
-                    'partner_id': so.partner_id.id,
-                    'product_id': product.id,
-                    'original_sale_order_id': so.id,
-                    'interval_months': interval,
-                    'next_due_date': today + relativedelta(months=interval),
-                    'state': 'active',
-                })
+                anchor = so._fc_maintenance_anchor_date(line)
+                # One contract per serialized unit; without a serial, per quantity.
+                count = 1 if serial else max(int(line.product_uom_qty or 1), 1)
+                for _i in range(count):
+                    Contract.create({
+                        'partner_id': so.partner_id.id,
+                        'product_id': product.id,
+                        'original_sale_order_id': so.id,
+                        'x_fc_source_sale_line_id': line.id,
+                        'x_fc_source': 'sale',
+                        'x_fc_device_serial': serial,
+                        'x_fc_policy_category_id': category.id if category else False,
+                        'interval_months': interval,
+                        'x_fc_maintenance_fee': fee,
+                        'next_due_date': anchor + relativedelta(months=interval),
+                        'state': 'active',
+                    })

fusion_repairs/models/product_template.py

@@ -26,6 +26,10 @@ class ProductTemplate(models.Model):
         help='If > 0, delivering a unit of this product auto-creates a maintenance contract '
              'with this recurring interval. Phase 3 feature.',
     )
+    x_fc_maintenance_fee = fields.Monetary(
+        string='Maintenance Fee (override)', currency_field='currency_id',
+        help='Per-product override of the category maintenance fee. 0 = use the category fee.',
+    )
     x_fc_intake_template_id = fields.Many2one(
         'fusion.repair.intake.template',
         string='Intake Template Override',

fusion_repairs/models/repair_product_category.py

@@ -53,6 +53,31 @@ class FusionRepairProductCategory(models.Model):
         help='Default intake question set shown when this category is selected.',
     )
 
+    # ── Maintenance policy (per equipment type) ──────────────────────────
+    x_fc_maintenance_enabled = fields.Boolean(
+        string='Offer Maintenance',
+        help='If set, units in this category are enrolled in recurring preventive '
+             'maintenance on sale (and via the backfill wizard).',
+    )
+    x_fc_maintenance_interval_months = fields.Integer(
+        string='Maintenance Interval (Months)', default=6,
+        help='Default months between preventive maintenance visits for this category. '
+             'Overridden by the product field of the same name when that is > 0.',
+    )
+    currency_id = fields.Many2one(
+        'res.currency', string='Currency',
+        default=lambda self: self.env.company.currency_id,
+    )
+    x_fc_maintenance_fee = fields.Monetary(
+        string='Maintenance Fee', currency_field='currency_id',
+        help='Flat fee shown to the client for a maintenance visit of this equipment type.',
+    )
+    x_fc_maintenance_service_product_id = fields.Many2one(
+        'product.product', string='Maintenance Service Product',
+        help='Optional product used when drafting the priced visit line (Plan 2). '
+             'Falls back to a generic visit product.',
+    )
+
     _code_unique = models.Constraint(
         'unique(code)',
         'Category code must be unique.',

fusion_repairs/models/repair_service_plan.py

@@ -247,6 +247,7 @@ class SaleOrder(models.Model):
         # Bundle 9: spawn store labor warranties for any product line with
         # x_fc_labor_warranty_years > 0.
         self._fc_spawn_labor_warranties()
+        self._spawn_maintenance_contracts()
         return res
 
     def _fc_spawn_labor_warranties(self):

fusion_repairs/tests/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from . import test_maintenance_foundation

fusion_repairs/tests/test_maintenance_foundation.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+from odoo.tests import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install')
+class TestMaintenanceFoundation(TransactionCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.partner = cls.env['res.partner'].create({'name': 'Mrs. Test Client'})
+        cls.category = cls.env['fusion.repair.product.category'].create({
+            'name': 'Stair Lift', 'code': 'stairlift_test',
+            'equipment_class': 'lift_elevating', 'safety_critical': True,
+            'x_fc_maintenance_enabled': True,
+            'x_fc_maintenance_interval_months': 6,
+            'x_fc_maintenance_fee': 149.0,
+        })
+
+    # ---- Tasks 1/2/3: fields exist ----
+    def test_category_policy_fields(self):
+        self.assertTrue(self.category.x_fc_maintenance_enabled)
+        self.assertEqual(self.category.x_fc_maintenance_interval_months, 6)
+        self.assertEqual(self.category.x_fc_maintenance_fee, 149.0)
+        self.assertTrue(self.category.currency_id)
+
+    def test_product_fee_override_field(self):
+        tmpl = self.env['product.template'].create({
+            'name': 'Handicare Freecurve Stairlift',
+            'x_fc_repair_category_id': self.category.id,
+            'x_fc_maintenance_fee': 199.0,
+        })
+        self.assertEqual(tmpl.x_fc_maintenance_fee, 199.0)
+
+    def test_contract_extension_fields(self):
+        product = self.env['product.product'].create({'name': 'Unit'})
+        c = self.env['fusion.repair.maintenance.contract'].create({
+            'partner_id': self.partner.id,
+            'product_id': product.id,
+            'next_due_date': '2026-12-01',
+            'x_fc_source': 'sale',
+            'x_fc_device_serial': 'SN-123',
+            'x_fc_maintenance_fee': 149.0,
+        })
+        self.assertEqual(c.x_fc_source, 'sale')
+        self.assertEqual(c.x_fc_device_serial, 'SN-123')
+        self.assertEqual(c.x_fc_maintenance_fee, 149.0)
+
+    # ---- Task 4: spawn priced contracts on sale confirm ----
+    def _make_product(self, **kw):
+        vals = {'name': 'Stairlift Unit', 'type': 'consu',
+                'x_fc_repair_category_id': self.category.id}
+        vals.update(kw)
+        return self.env['product.product'].create(vals)
+
+    def _confirm_so(self, product, commitment='2026-01-10'):
+        so = self.env['sale.order'].create({
+            'partner_id': self.partner.id,
+            'commitment_date': commitment,
+            'order_line': [(0, 0, {'product_id': product.id, 'product_uom_qty': 1})],
+        })
+        so.action_confirm()
+        return so
+
+    def _contracts_for(self, so):
+        return self.env['fusion.repair.maintenance.contract'].search(
+            [('original_sale_order_id', '=', so.id)])
+
+    def test_no_contract_when_category_not_maintainable(self):
+        cat = self.env['fusion.repair.product.category'].create(
+            {'name': 'Cane', 'code': 'cane_test', 'x_fc_maintenance_enabled': False})
+        so = self._confirm_so(self._make_product(x_fc_repair_category_id=cat.id))
+        self.assertFalse(self._contracts_for(so))
+
+    def test_contract_created_via_category_policy(self):
+        so = self._confirm_so(self._make_product())
+        contracts = self._contracts_for(so)
+        self.assertEqual(len(contracts), 1)
+        c = contracts
+        self.assertEqual(c.interval_months, 6)
+        self.assertEqual(c.x_fc_maintenance_fee, 149.0)
+        self.assertEqual(c.x_fc_source, 'sale')
+        self.assertEqual(c.x_fc_policy_category_id, self.category)
+        # anchor = commitment_date (2026-01-10) + 6 months
+        self.assertEqual(str(c.next_due_date), '2026-07-10')
+
+    def test_product_override_beats_category(self):
+        p = self._make_product()
+        p.product_tmpl_id.x_fc_maintenance_interval_months = 3
+        p.product_tmpl_id.x_fc_maintenance_fee = 199.0
+        so = self._confirm_so(p)
+        c = self._contracts_for(so)
+        self.assertEqual(c.interval_months, 3)
+        self.assertEqual(c.x_fc_maintenance_fee, 199.0)
+
+    def test_idempotent_on_reconfirm(self):
+        p = self._make_product()
+        so = self._confirm_so(p)
+        so._spawn_maintenance_contracts()  # call again -> no duplicate
+        self.assertEqual(len(self._contracts_for(so)), 1)

fusion_repairs/views/menus.xml

@@ -57,6 +57,13 @@
               action="action_repair_part_order"
               sequence="38"/>
 
+    <!-- Configuration parent: must be defined before the children that reference it below -->
+    <menuitem id="menu_fusion_repairs_configuration"
+              name="Configuration"
+              parent="menu_fusion_repairs_root"
+              sequence="90"
+              groups="fusion_repairs.group_fusion_repairs_manager"/>
+
     <menuitem id="menu_fusion_repairs_emergency_charges"
               name="Emergency Surcharges"
               parent="menu_fusion_repairs_configuration"
@@ -100,13 +107,6 @@
               action="action_repair_labor_warranty"
               sequence="36"/>
 
-    <!-- Configuration -->
-    <menuitem id="menu_fusion_repairs_configuration"
-              name="Configuration"
-              parent="menu_fusion_repairs_root"
-              sequence="90"
-              groups="fusion_repairs.group_fusion_repairs_manager"/>
-
     <menuitem id="menu_fusion_repairs_categories"
               name="Equipment Categories"
               parent="menu_fusion_repairs_configuration"

fusion_repairs/views/repair_product_category_views.xml

@@ -40,6 +40,13 @@
                             <field name="active"/>
                         </group>
                     </group>
+                    <group string="Maintenance Policy">
+                        <field name="x_fc_maintenance_enabled"/>
+                        <field name="x_fc_maintenance_interval_months" invisible="not x_fc_maintenance_enabled"/>
+                        <field name="x_fc_maintenance_fee" invisible="not x_fc_maintenance_enabled"/>
+                        <field name="x_fc_maintenance_service_product_id" invisible="not x_fc_maintenance_enabled"/>
+                        <field name="currency_id" invisible="1"/>
+                    </group>
                     <field name="description" placeholder="Describe what equipment falls into this category..."/>
                 </sheet>
             </form>