diff --git a/fusion_plating/docs/superpowers/plans/2026-05-26-express-orders-plan.md b/fusion_plating/docs/superpowers/plans/2026-05-26-express-orders-plan.md
new file mode 100644
index 00000000..1cbe903d
--- /dev/null
+++ b/fusion_plating/docs/superpowers/plans/2026-05-26-express-orders-plan.md
@@ -0,0 +1,2757 @@
+# Express Orders Implementation Plan
+
+> **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:** Replace the slow form-per-part Direct Order wizard with a spreadsheet-style "Express Orders" view that supports fast batch entry — all lines on one screen, type-once-and-remember per-part defaults, masking + bake toggles per line that drive job-creation overrides.
+
+**Architecture:** Reuse the existing persistent `fp.direct.order.wizard` + `fp.direct.order.line` models end-to-end (Q1=D). Add per-line Express flags (`masking_enabled`, `bake_instructions`, `customer_line_ref`) that persist as plain fields. At SO confirm, a new helper on `sale.order.line` reads those flags and writes `fp.job.node.override` rows + `fp.job.step.instructions` text in one pass. Build a parallel Express form view; the legacy view stays alive during a 4-phase soft retirement.
+
+**Tech Stack:** Odoo 19 (Python 3.11), PostgreSQL, OWL 2 (custom widgets), QWeb XML, SCSS (compile-time dark-mode branching). Tests: `odoo.tests.common.TransactionCase`.
+
+**Spec:** [docs/superpowers/specs/2026-05-26-express-orders-design.md](../specs/2026-05-26-express-orders-design.md)
+
+**Visual reference:** [.claude/mockups/express_orders.html](../../../.claude/mockups/express_orders.html) (interactive light + dark; three tabs — Screen / Data Flow / Comparison)
+
+---
+
+## File Structure
+
+### Files to CREATE
+
+```
+fusion_plating_configurator/
+├── migrations/19.0.22.0.0/
+│   ├── pre-migrate.py                          # rename notes → terms_and_conditions; backfill pricelist_id
+│   └── post-migrate.py                         # drop currency_id; orphan-landing-action sweep (Phase 4)
+├── models/
+│   └── product_pricelist.py                    # context-aware display_name override (NEW small file)
+├── views/
+│   ├── fp_express_order_views.xml              # Express form + action + menu item
+│   └── fp_part_catalog_quick_create_views.xml  # 4-field quick-create form for inline part create
+├── static/src/
+│   ├── js/
+│   │   ├── express_part_cell.js                # OWL widget — multi-row Part cell
+│   │   └── express_bake_pill.js                # OWL widget — bake pill with inline popover
+│   ├── xml/
+│   │   ├── express_part_cell.xml               # Template for part cell widget
+│   │   └── express_bake_pill.xml               # Template for bake pill widget
+│   └── scss/
+│       ├── _express_tokens.scss                # colour tokens, dark-mode compile-time branch
+│       └── express_order.scss                  # styles for Express form
+└── tests/
+    ├── test_express_part_defaults.py
+    ├── test_express_line_fields.py
+    ├── test_express_so_line_fields.py
+    ├── test_express_wizard_fields.py
+    ├── test_express_sale_order_fields.py
+    ├── test_express_overrides.py               # _fp_apply_express_overrides_to_job — the meaty one
+    ├── test_express_recipe_walker.py
+    ├── test_express_onchange_autofill.py
+    ├── test_express_part_writeback.py
+    ├── test_express_drafts_routing.py
+    └── test_express_bulk_serial_trigger.py
+```
+
+### Files to MODIFY
+
+```
+fusion_plating_configurator/
+├── __manifest__.py                                       # bump 19.0.21.8.4 → 19.0.22.0.0; add data + assets
+├── models/
+│   ├── fp_part_catalog.py                                # +3 fields
+│   ├── sale_order.py                                     # +3 fields
+│   └── sale_order_line.py                                # +3 fields, +4 methods
+├── wizard/
+│   ├── fp_direct_order_wizard.py                         # +5 fields, rename notes, retire currency_id, add view_source
+│   ├── fp_direct_order_line.py                           # +3 fields, +3 mirror methods, extend onchange
+│   └── fp_direct_order_wizard_views.xml                  # Phase 2 deprecation banner; drafts list view_source column
+fusion_plating_jobs/
+└── models/sale_order.py                                  # extend _fp_auto_create_job to call new helper
+fusion_plating/
+└── models/fp_process_node.py                             # +1 helper method _fp_all_nodes_with_kind
+```
+
+### Module version bump
+
+`fusion_plating_configurator/__manifest__.py`: `19.0.21.8.4` → `19.0.22.0.0`. Bump happens once in Task A0.
+
+---
+
+## How to run tests
+
+**Local dev (Docker, Mac):**
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev \
+  -u fusion_plating_configurator,fusion_plating_jobs,fusion_plating \
+  --test-enable --test-tags /fusion_plating_configurator \
+  --stop-after-init 2>&1 | tail -40
+```
+
+**Single test file:**
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev \
+  -u fusion_plating_configurator \
+  --test-enable --test-tags /fusion_plating_configurator:TestExpressOverrides \
+  --stop-after-init 2>&1 | tail -40
+```
+
+**View parse check (XML only, no test):**
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev \
+  -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error|warning" | head -20
+```
+
+Expected outcome of a passing run: `Modules loaded.` near the end, no `ERROR` lines.
+
+---
+
+## Phase A — Schema layer
+
+### Task A0: Bump module version + create migration directory
+
+**Files:**
+- Modify: `fusion_plating_configurator/__manifest__.py`
+- Create: `fusion_plating_configurator/migrations/19.0.22.0.0/__init__.py` (empty)
+
+- [ ] **Step 1: Bump version**
+
+Edit `fusion_plating_configurator/__manifest__.py`:
+
+```python
+'version': '19.0.22.0.0',
+```
+
+- [ ] **Step 2: Create migration directory**
+
+```bash
+mkdir -p fusion_plating_configurator/migrations/19.0.22.0.0
+touch fusion_plating_configurator/migrations/19.0.22.0.0/__init__.py
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add fusion_plating_configurator/__manifest__.py fusion_plating_configurator/migrations/19.0.22.0.0/__init__.py
+git commit -m "chore(configurator): bump to 19.0.22.0.0 for Express Orders"
+```
+
+---
+
+### Task A1: Add per-part Express defaults to `fp.part.catalog`
+
+**Files:**
+- Modify: `fusion_plating_configurator/models/fp_part_catalog.py`
+- Create: `fusion_plating_configurator/tests/test_express_part_defaults.py`
+- Modify: `fusion_plating_configurator/tests/__init__.py` (add the new test import)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `fusion_plating_configurator/tests/test_express_part_defaults.py`:
+
+```python
+# -*- coding: utf-8 -*-
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressPartDefaults(TransactionCase):
+    def test_new_fields_exist(self):
+        Part = self.env['fp.part.catalog']
+        self.assertIn('default_specification_text', Part._fields)
+        self.assertIn('default_bake_instructions', Part._fields)
+        self.assertIn('default_masking_enabled', Part._fields)
+
+    def test_default_masking_enabled_default_value(self):
+        partner = self.env['res.partner'].create({'name': 'Test Customer'})
+        part = self.env['fp.part.catalog'].create({
+            'partner_id': partner.id,
+            'part_number': 'TEST-001',
+            'revision': 'A',
+            'name': 'Test Part',
+        })
+        self.assertTrue(part.default_masking_enabled)
+        self.assertFalse(part.default_specification_text)
+        self.assertFalse(part.default_bake_instructions)
+```
+
+Add to `fusion_plating_configurator/tests/__init__.py`:
+```python
+from . import test_express_part_defaults
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev \
+  -u fusion_plating_configurator \
+  --test-enable --test-tags fp_express \
+  --stop-after-init 2>&1 | tail -30
+```
+
+Expected: `KeyError: 'default_specification_text'` or `AssertionError`.
+
+- [ ] **Step 3: Add the fields**
+
+Edit `fusion_plating_configurator/models/fp_part_catalog.py` — add inside the `FpPartCatalog` class (e.g. after the existing `x_fc_default_thickness_range` field):
+
+```python
+    # ---- Express Orders defaults (2026-05-26) ----
+    default_specification_text = fields.Text(
+        string='Default Specification (Customer-Facing)',
+        help='Pre-fills the Specification cell when this part is added to an '
+             'Express Order. Written here automatically on order confirm — '
+             'type once, reuse forever.',
+    )
+    default_bake_instructions = fields.Text(
+        string='Default Bake Instructions',
+        help='Pre-fills the Bake cell. Empty = bake step is skipped on every '
+             'order; non-empty = bake step runs and these instructions show '
+             'on the operator tablet.',
+    )
+    default_masking_enabled = fields.Boolean(
+        string='Default Masking Enabled',
+        default=True,
+        help='Default state of the Masking checkbox on Express Order lines. '
+             'When False, masking + de-masking recipe nodes are skipped.',
+    )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command as Step 2.
+Expected: `OK` and `Modules loaded.`
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/models/fp_part_catalog.py fusion_plating_configurator/tests/test_express_part_defaults.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): add Express Orders per-part defaults to fp.part.catalog"
+```
+
+---
+
+### Task A2: Add Express flags to `fp.direct.order.line`
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_line.py`
+- Create: `fusion_plating_configurator/tests/test_express_line_fields.py`
+- Modify: `fusion_plating_configurator/tests/__init__.py`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `fusion_plating_configurator/tests/test_express_line_fields.py`:
+
+```python
+# -*- coding: utf-8 -*-
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressLineFields(TransactionCase):
+    def test_new_fields_exist(self):
+        Line = self.env['fp.direct.order.line']
+        self.assertIn('customer_line_ref', Line._fields)
+        self.assertIn('masking_enabled', Line._fields)
+        self.assertIn('bake_instructions', Line._fields)
+
+    def test_masking_default_true(self):
+        partner = self.env['res.partner'].create({'name': 'Cust'})
+        wiz = self.env['fp.direct.order.wizard'].create({'partner_id': partner.id})
+        line = self.env['fp.direct.order.line'].create({
+            'wizard_id': wiz.id,
+            'quantity': 1,
+        })
+        self.assertTrue(line.masking_enabled)
+        self.assertFalse(line.customer_line_ref)
+        self.assertFalse(line.bake_instructions)
+```
+
+Add `from . import test_express_line_fields` to `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: `KeyError`.
+
+- [ ] **Step 3: Add the fields**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_line.py` — add inside the `FpDirectOrderLine` class (near other line-level fields):
+
+```python
+    # ---- Express Orders per-line flags (2026-05-26) ----
+    customer_line_ref = fields.Char(
+        string='Customer Line Job #',
+        help='Per-line customer sub-reference (e.g. ABC, DEF). Distinct from '
+             'the order-level Customer Job #. Prints on customer docs.',
+    )
+    masking_enabled = fields.Boolean(
+        string='Masking Enabled',
+        default=True,
+        help='When False, masking + de-masking recipe nodes are opted out '
+             'when the job is created.',
+    )
+    bake_instructions = fields.Text(
+        string='Bake Instructions',
+        help='Free-text bake instructions. Empty = bake steps are opted out. '
+             'Non-empty = bake step instructions on the operator tablet.',
+    )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command as Step 2.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_line.py fusion_plating_configurator/tests/test_express_line_fields.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): add Express flags to fp.direct.order.line"
+```
+
+---
+
+### Task A3: Add Express flags to `sale.order.line`
+
+**Files:**
+- Modify: `fusion_plating_configurator/models/sale_order_line.py`
+- Create: `fusion_plating_configurator/tests/test_express_so_line_fields.py`
+- Modify: `fusion_plating_configurator/tests/__init__.py`
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_express_so_line_fields.py`:
+
+```python
+# -*- coding: utf-8 -*-
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressSoLineFields(TransactionCase):
+    def test_new_fields_exist(self):
+        Line = self.env['sale.order.line']
+        self.assertIn('x_fc_customer_line_ref', Line._fields)
+        self.assertIn('x_fc_masking_enabled', Line._fields)
+        self.assertIn('x_fc_bake_instructions', Line._fields)
+
+    def test_masking_default_true(self):
+        partner = self.env['res.partner'].create({'name': 'C'})
+        product = self.env['product.product'].search([('default_code', '=', 'FP-SERVICE')], limit=1) \
+            or self.env['product.product'].create({'name': 'svc', 'type': 'service', 'default_code': 'FP-SERVICE'})
+        so = self.env['sale.order'].create({
+            'partner_id': partner.id,
+            'order_line': [(0, 0, {'product_id': product.id, 'product_uom_qty': 1})],
+        })
+        line = so.order_line[:1]
+        self.assertTrue(line.x_fc_masking_enabled)
+        self.assertFalse(line.x_fc_customer_line_ref)
+        self.assertFalse(line.x_fc_bake_instructions)
+```
+
+Wire up in `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: `KeyError`.
+
+- [ ] **Step 3: Add the fields**
+
+Edit `fusion_plating_configurator/models/sale_order_line.py` — add inside the class:
+
+```python
+    # ---- Express Orders per-line flags (2026-05-26) ----
+    # These mirror fp.direct.order.line.{customer_line_ref, masking_enabled, bake_instructions}
+    # and persist past wizard confirm so _fp_apply_express_overrides_to_job can read them.
+    x_fc_customer_line_ref = fields.Char(
+        string='Customer Line Job #',
+        help='Per-line customer sub-reference (e.g. ABC, DEF). '
+             'Prints on customer docs (quote, SO, invoice, packing slip).',
+    )
+    x_fc_masking_enabled = fields.Boolean(
+        string='Masking Enabled',
+        default=True,
+        help='When False, the job-creation hook spawns fp.job.node.override '
+             '(included=False) for every masking + de_masking node on the recipe.',
+    )
+    x_fc_bake_instructions = fields.Text(
+        string='Bake Instructions',
+        help='Empty = bake steps are opted out of the job. Non-empty = bake '
+             'steps run, with this text shown on the operator tablet under '
+             'fp.job.step.instructions.',
+    )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command as Step 2.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/models/sale_order_line.py fusion_plating_configurator/tests/test_express_so_line_fields.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): add Express flags to sale.order.line"
+```
+
+---
+
+### Task A4: Add Express fields to `sale.order` (header-level x_fc_*)
+
+**Files:**
+- Modify: `fusion_plating_configurator/models/sale_order.py`
+- Create: `fusion_plating_configurator/tests/test_express_sale_order_fields.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_sale_order_fields.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressSaleOrderFields(TransactionCase):
+    def test_new_fields_exist(self):
+        SO = self.env['sale.order']
+        self.assertIn('x_fc_material_process', SO._fields)
+        self.assertIn('x_fc_internal_notes', SO._fields)
+        self.assertIn('x_fc_print_terms', SO._fields)
+
+    def test_print_terms_default_true(self):
+        partner = self.env['res.partner'].create({'name': 'C'})
+        so = self.env['sale.order'].create({'partner_id': partner.id})
+        self.assertTrue(so.x_fc_print_terms)
+```
+
+Wire up in `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: `KeyError`.
+
+- [ ] **Step 3: Add the fields**
+
+Edit `fusion_plating_configurator/models/sale_order.py` — add inside the class:
+
+```python
+    # ---- Express Orders header-level (2026-05-26) ----
+    x_fc_material_process = fields.Char(
+        string='Material / Process Tag',
+        help='Free-text order-level shop tag (e.g. ENP-STEEL-HP-ADVANCED). '
+             'Informational; not used by the workflow.',
+    )
+    x_fc_internal_notes = fields.Text(
+        string='Order-Level Internal Notes',
+        help='Notes visible only to the estimator / planner / shop. Never '
+             'prints on customer-facing PDFs. Distinct from sale.order.note '
+             'which IS customer-facing (Terms & Conditions).',
+    )
+    x_fc_print_terms = fields.Boolean(
+        string='Print Terms on Customer Documents',
+        default=True,
+        help='When False, the Terms & Conditions (sale.order.note) is '
+             'suppressed on quote / SO / invoice / packing slip PDFs.',
+    )
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/models/sale_order.py fusion_plating_configurator/tests/test_express_sale_order_fields.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): add Express header fields to sale.order"
+```
+
+---
+
+### Task A5: Wizard schema — new fields + rename `notes` + retire `currency_id`
+
+This task is bigger because it does three things at once. The model edits + the pre-migration script must land together so the upgrade is atomic.
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard.py`
+- Create: `fusion_plating_configurator/migrations/19.0.22.0.0/pre-migrate.py`
+- Create: `fusion_plating_configurator/tests/test_express_wizard_fields.py`
+- Modify: `fusion_plating_configurator/tests/__init__.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_wizard_fields.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressWizardFields(TransactionCase):
+    def test_new_fields_exist(self):
+        Wiz = self.env['fp.direct.order.wizard']
+        for fname in ('material_process', 'pricelist_id', 'validity_date',
+                      'internal_notes', 'terms_and_conditions', 'view_source'):
+            self.assertIn(fname, Wiz._fields, msg=f'Missing: {fname}')
+
+    def test_old_currency_id_retired(self):
+        # currency_id is gone from the model class (was M2O res.currency)
+        Wiz = self.env['fp.direct.order.wizard']
+        self.assertNotIn('currency_id', Wiz._fields)
+
+    def test_old_notes_retired(self):
+        Wiz = self.env['fp.direct.order.wizard']
+        self.assertNotIn('notes', Wiz._fields)
+
+    def test_view_source_default_express(self):
+        partner = self.env['res.partner'].create({'name': 'C'})
+        wiz = self.env['fp.direct.order.wizard'].create({'partner_id': partner.id})
+        self.assertEqual(wiz.view_source, 'express')
+```
+
+Wire up in `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: multiple `AssertionError: Missing: …`.
+
+- [ ] **Step 3a: Add new fields + rename + retire on the model**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_wizard.py`:
+
+(a) Find the `currency_id` field declaration and **delete it entirely** (lines 142–145 in the current file).
+
+(b) Find the `notes` field declaration and **replace** it with `terms_and_conditions`:
+
+```python
+    terms_and_conditions = fields.Text(
+        string='Terms & Conditions',
+        help='Customer-facing terms — prints on quote / SO / invoice. '
+             'Seeded from res.company.invoice_terms_html with partner-level '
+             'override via res.partner.invoice_terms.',
+    )
+    internal_notes = fields.Text(
+        string='Order-Level Internal Notes',
+        help='Visible only to estimator / planner / shop. Never prints.',
+    )
+```
+
+(c) Add the remaining new fields (near other order-level fields):
+
+```python
+    # ---- Express Orders header (2026-05-26) ----
+    material_process = fields.Char(
+        string='Material / Process Tag',
+        help='Free-text shop tag (e.g. ENP-STEEL-HP-ADVANCED).',
+    )
+    pricelist_id = fields.Many2one(
+        'product.pricelist',
+        string='Pricelist',
+        default=lambda self: self._fp_default_pricelist(),
+        help='Drives both order currency and price computation. Replaces the '
+             'legacy currency_id Many2one(res.currency).',
+    )
+    validity_date = fields.Date(
+        string='Quote Validity',
+        help='Mirrors sale.order.validity_date — when the quote/SO expires.',
+    )
+    view_source = fields.Selection(
+        [('express', 'Express Orders View'),
+         ('legacy', 'Legacy Direct Order View')],
+        string='View Source',
+        default='express',
+        required=True,
+        readonly=True,
+        help='Which view created this draft. Drafts list routes click-action '
+             'to the matching form. Dropped at phase-out Phase 4.',
+    )
+
+    @api.model
+    def _fp_default_pricelist(self):
+        """Default pricelist = company's default. Re-resolves on partner pick."""
+        return self.env.company.partner_id.property_product_pricelist.id or False
+```
+
+(d) Update `_prepare_order_vals()` — find the dict that builds the SO header (around line 528) and **replace**:
+
+```python
+            'note': self.notes or False,
+```
+
+with:
+
+```python
+            'note': self.terms_and_conditions or False,
+            'x_fc_internal_notes': self.internal_notes or False,
+            'x_fc_material_process': self.material_process or False,
+            'pricelist_id': self.pricelist_id.id if self.pricelist_id else False,
+            'validity_date': self.validity_date or False,
+```
+
+- [ ] **Step 3b: Add the pre-migration script**
+
+Create `fusion_plating_configurator/migrations/19.0.22.0.0/pre-migrate.py`:
+
+```python
+# -*- coding: utf-8 -*-
+"""Pre-migration for Express Orders (19.0.22.0.0).
+
+Runs BEFORE Odoo's field-registration pass so the model can register
+`terms_and_conditions` and `pricelist_id` against columns that already
+hold data:
+
+1. Rename `fp_direct_order_wizard.notes` → `terms_and_conditions`.
+2. Add `pricelist_id` column.
+3. Backfill `pricelist_id` from the now-retired `currency_id` via the
+   partner's property_product_pricelist, with fallback to any active
+   pricelist matching the wizard's currency.
+4. Drop `currency_id` column (safe — we are in development on entech;
+   the spec explicitly says ignore past orders).
+"""
+
+
+def migrate(cr, version):
+    # 1. Rename notes → terms_and_conditions (same column, same data)
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        RENAME COLUMN notes TO terms_and_conditions
+    """)
+
+    # 2. Add internal_notes column (will be NULL for existing rows)
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        ADD COLUMN IF NOT EXISTS internal_notes TEXT
+    """)
+
+    # 3. Add pricelist_id, material_process, validity_date, view_source
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        ADD COLUMN IF NOT EXISTS pricelist_id INTEGER
+            REFERENCES product_pricelist(id) ON DELETE SET NULL
+    """)
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        ADD COLUMN IF NOT EXISTS material_process VARCHAR
+    """)
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        ADD COLUMN IF NOT EXISTS validity_date DATE
+    """)
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        ADD COLUMN IF NOT EXISTS view_source VARCHAR DEFAULT 'legacy'
+    """)
+    # Note: view_source defaults to 'legacy' for existing rows — they
+    # were created via the legacy view. New rows default to 'express'
+    # via the model definition.
+
+    # 4. Backfill pricelist_id from partner's property if available,
+    #    else any active pricelist in the same currency.
+    cr.execute("""
+        UPDATE fp_direct_order_wizard w
+        SET pricelist_id = (
+            SELECT p.id
+            FROM product_pricelist p
+            WHERE p.currency_id = w.currency_id
+              AND p.active = TRUE
+            ORDER BY p.id
+            LIMIT 1
+        )
+        WHERE w.pricelist_id IS NULL
+          AND w.currency_id IS NOT NULL
+    """)
+
+    # 5. Drop the retired currency_id column (dev-stage, no legacy concerns)
+    cr.execute("""
+        ALTER TABLE fp_direct_order_wizard
+        DROP COLUMN IF EXISTS currency_id
+    """)
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: `OK`. If the pre-migrate script errored on a column that doesn't exist (clean DB), the `IF NOT EXISTS` / `IF EXISTS` clauses cover it.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_wizard.py fusion_plating_configurator/migrations/19.0.22.0.0/pre-migrate.py fusion_plating_configurator/tests/test_express_wizard_fields.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): wizard schema — rename notes, add Express fields, retire currency_id"
+```
+
+---
+
+## Phase B — Backend logic
+
+### Task B1: Recipe-walker helper `_fp_all_nodes_with_kind`
+
+**Files:**
+- Modify: `fusion_plating/models/fp_process_node.py`
+- Create: `fusion_plating_configurator/tests/test_express_recipe_walker.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_recipe_walker.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressRecipeWalker(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        Node = self.env['fusion.plating.process.node']
+        self.root = Node.create({'name': 'Root', 'node_type': 'recipe'})
+        self.op_mask = Node.create({
+            'name': 'Mask', 'node_type': 'operation',
+            'parent_id': self.root.id, 'default_kind': 'masking',
+        })
+        self.op_bake = Node.create({
+            'name': 'Bake @ 350', 'node_type': 'operation',
+            'parent_id': self.root.id, 'default_kind': 'baking',
+        })
+        self.op_demask = Node.create({
+            'name': 'De-Mask', 'node_type': 'operation',
+            'parent_id': self.root.id, 'default_kind': 'de_masking',
+        })
+        self.op_other = Node.create({
+            'name': 'Inspect', 'node_type': 'operation',
+            'parent_id': self.root.id, 'default_kind': 'inspection',
+        })
+
+    def test_finds_masking_pair(self):
+        nodes = self.root._fp_all_nodes_with_kind(('masking', 'de_masking'))
+        self.assertEqual(set(nodes.ids), {self.op_mask.id, self.op_demask.id})
+
+    def test_finds_baking(self):
+        nodes = self.root._fp_all_nodes_with_kind(('baking',))
+        self.assertEqual(set(nodes.ids), {self.op_bake.id})
+
+    def test_empty_kinds_returns_empty(self):
+        self.assertFalse(self.root._fp_all_nodes_with_kind(()))
+
+    def test_kind_not_present_returns_empty(self):
+        self.assertFalse(self.root._fp_all_nodes_with_kind(('nonexistent',)))
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator,fusion_plating --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: `AttributeError: 'fusion.plating.process.node' object has no attribute '_fp_all_nodes_with_kind'`.
+
+- [ ] **Step 3: Add the helper**
+
+Edit `fusion_plating/models/fp_process_node.py` — add as a method on the class:
+
+```python
+    def _fp_all_nodes_with_kind(self, kinds):
+        """Return all descendants (incl. self if applicable) whose default_kind ∈ kinds.
+
+        Uses _parent_store's parent_path for a single SQL hit. Added 2026-05-26
+        for Express Orders override-application helper.
+
+        :param kinds: tuple/list of default_kind strings, e.g. ('masking', 'de_masking')
+        :return: recordset of matching fusion.plating.process.node rows
+        """
+        self.ensure_one()
+        if not kinds:
+            return self.browse([])
+        return self.search([
+            ('id', 'child_of', self.id),
+            ('default_kind', 'in', list(kinds)),
+        ])
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating/models/fp_process_node.py fusion_plating_configurator/tests/test_express_recipe_walker.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(plating): recipe walker _fp_all_nodes_with_kind for Express Orders"
+```
+
+---
+
+### Task B2: Override-application helper `_fp_apply_express_overrides_to_job`
+
+This is the meatiest backend piece — it covers the 4 quadrants (masking on/off × bake empty/non-empty) plus audit + idempotency.
+
+**Files:**
+- Modify: `fusion_plating_configurator/models/sale_order_line.py`
+- Create: `fusion_plating_configurator/tests/test_express_overrides.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_overrides.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressOverrides(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        Node = self.env['fusion.plating.process.node']
+        # Build a minimal recipe: Mask → Plate → Bake → De-Mask → Inspect
+        self.recipe = Node.create({'name': 'Test ENP', 'node_type': 'recipe'})
+        self.n_mask = Node.create({
+            'name': 'Mask', 'node_type': 'operation',
+            'parent_id': self.recipe.id, 'default_kind': 'masking', 'sequence': 10,
+        })
+        self.n_plate = Node.create({
+            'name': 'Plate', 'node_type': 'operation',
+            'parent_id': self.recipe.id, 'default_kind': 'plating', 'sequence': 20,
+        })
+        self.n_bake = Node.create({
+            'name': 'Bake', 'node_type': 'operation',
+            'parent_id': self.recipe.id, 'default_kind': 'baking', 'sequence': 30,
+        })
+        self.n_demask = Node.create({
+            'name': 'De-Mask', 'node_type': 'operation',
+            'parent_id': self.recipe.id, 'default_kind': 'de_masking', 'sequence': 40,
+        })
+
+        # Build a minimal SO + line + fp.job + steps
+        partner = self.env['res.partner'].create({'name': 'C'})
+        product = self.env['product.product'].search([('default_code', '=', 'FP-SERVICE')], limit=1) \
+            or self.env['product.product'].create({'name': 'svc', 'type': 'service', 'default_code': 'FP-SERVICE'})
+        self.so = self.env['sale.order'].create({
+            'partner_id': partner.id,
+            'order_line': [(0, 0, {'product_id': product.id, 'product_uom_qty': 1})],
+        })
+        self.line = self.so.order_line[:1]
+        self.job = self.env['fp.job'].create({
+            'partner_id': partner.id,
+            'recipe_id': self.recipe.id,
+            'qty': 1,
+            'sale_order_id': self.so.id,
+        })
+        # Spawn job steps from the recipe (one per operation node)
+        FpStep = self.env['fp.job.step']
+        for node in (self.n_mask, self.n_plate, self.n_bake, self.n_demask):
+            FpStep.create({
+                'job_id': self.job.id,
+                'recipe_node_id': node.id,
+                'name': node.name,
+                'sequence': node.sequence,
+            })
+
+    def _count_overrides(self, kinds, included=False):
+        return self.env['fp.job.node.override'].search_count([
+            ('job_id', '=', self.job.id),
+            ('node_id.default_kind', 'in', list(kinds)),
+            ('included', '=', included),
+        ])
+
+    def test_masking_off_creates_pair_overrides(self):
+        self.line.x_fc_masking_enabled = False
+        self.line.x_fc_bake_instructions = '350F x 4hr'  # avoid bake opt-out
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        self.assertEqual(self._count_overrides(('masking', 'de_masking')), 2)
+
+    def test_masking_on_creates_no_masking_overrides(self):
+        self.line.x_fc_masking_enabled = True
+        self.line.x_fc_bake_instructions = '350F x 4hr'
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        self.assertEqual(self._count_overrides(('masking', 'de_masking')), 0)
+
+    def test_bake_empty_opts_out_baking_nodes(self):
+        self.line.x_fc_masking_enabled = True
+        self.line.x_fc_bake_instructions = ''
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        self.assertEqual(self._count_overrides(('baking',)), 1)
+
+    def test_bake_whitespace_only_treated_as_empty(self):
+        self.line.x_fc_bake_instructions = '   \n  '
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        self.assertEqual(self._count_overrides(('baking',)), 1)
+
+    def test_bake_text_writes_to_step_instructions(self):
+        self.line.x_fc_masking_enabled = True
+        self.line.x_fc_bake_instructions = '350F x 4hr'
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        bake_step = self.job.step_ids.filtered(
+            lambda s: s.recipe_node_id.default_kind == 'baking'
+        )
+        self.assertEqual(bake_step.instructions, '350F x 4hr')
+
+    def test_idempotent_rerun_does_not_duplicate(self):
+        self.line.x_fc_masking_enabled = False
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        self.line._fp_apply_express_overrides_to_job(self.job)
+        # Second run should pre-delete prior rows then re-create — net same count
+        self.assertEqual(self._count_overrides(('masking', 'de_masking')), 2)
+
+    def test_no_recipe_no_op(self):
+        self.job.recipe_id = False
+        self.line._fp_apply_express_overrides_to_job(self.job)  # should not raise
+        self.assertEqual(self._count_overrides(('masking', 'de_masking', 'baking')), 0)
+```
+
+Wire up in `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -50
+```
+
+Expected: `AttributeError: '_fp_apply_express_overrides_to_job'`.
+
+- [ ] **Step 3: Implement the helper**
+
+Edit `fusion_plating_configurator/models/sale_order_line.py` — add to the class:
+
+```python
+    def _fp_apply_express_overrides_to_job(self, job):
+        """Convert Express per-line flags into fp.job.node.override rows + step instructions.
+
+        Called from sale_order._fp_auto_create_job() immediately after the
+        job + steps are built. Idempotent — pre-deletes prior masking/bake
+        override rows this helper wrote, so re-running on SO un-confirm +
+        re-confirm doesn't duplicate.
+
+        Algorithm per handoff Q4 (masking pair) + Q5 (bake text):
+        - masking_enabled=False → opt out of masking + de_masking nodes
+        - bake_instructions empty → opt out of baking nodes
+        - bake_instructions non-empty → keep baking + write text to step.instructions
+        """
+        self.ensure_one()
+        if not job or not job.recipe_id:
+            return
+
+        recipe = job.recipe_id
+        Override = self.env['fp.job.node.override']
+
+        # --- Idempotency: clear prior masking/bake overrides on this job
+        Override.search([
+            ('job_id', '=', job.id),
+            ('node_id.default_kind', 'in', ('masking', 'de_masking', 'baking')),
+        ]).unlink()
+
+        msgs = []
+
+        # --- 1. Masking — opt out of masking + de_masking AS A PAIR
+        if not self.x_fc_masking_enabled:
+            nodes = recipe._fp_all_nodes_with_kind(('masking', 'de_masking'))
+            for node in nodes:
+                Override.create({
+                    'job_id': job.id,
+                    'node_id': node.id,
+                    'included': False,
+                })
+            if nodes:
+                msgs.append('Masking + de-masking steps opted out (per SO line)')
+
+        # --- 2. Bake — empty = opt out; non-empty = keep + write step.instructions
+        bake_text = (self.x_fc_bake_instructions or '').strip()
+        bake_nodes = recipe._fp_all_nodes_with_kind(('baking',))
+        if not bake_text:
+            for node in bake_nodes:
+                Override.create({
+                    'job_id': job.id,
+                    'node_id': node.id,
+                    'included': False,
+                })
+            if bake_nodes:
+                msgs.append('Baking steps opted out (per SO line)')
+        else:
+            bake_steps = job.step_ids.filtered(
+                lambda s: s.recipe_node_id.default_kind == 'baking'
+            )
+            if bake_steps:
+                bake_steps.write({'instructions': bake_text})
+                msgs.append('Bake step instructions set to: %s' % bake_text)
+
+        # --- 3. Audit chatter post on the job
+        if msgs:
+            job.message_post(body='\n'.join('• ' + m for m in msgs))
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK` with all 7 sub-tests passing.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/models/sale_order_line.py fusion_plating_configurator/tests/test_express_overrides.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): Express override-application helper on sale.order.line"
+```
+
+---
+
+### Task B3: Hook helper into `_fp_auto_create_job`
+
+**Files:**
+- Modify: `fusion_plating_jobs/models/sale_order.py`
+- Add an integration test inside `tests/test_express_overrides.py`
+
+- [ ] **Step 1: Add the integration test**
+
+Append to `tests/test_express_overrides.py`:
+
+```python
+    def test_hook_fires_on_so_confirm(self):
+        """Confirming the SO should auto-call the override helper for each line."""
+        # Configure line to opt out of masking + bake
+        self.line.x_fc_masking_enabled = False
+        self.line.x_fc_bake_instructions = ''
+        # Reset job/step state — let action_confirm create them
+        self.job.unlink()
+
+        # Wire SO line to use the recipe via the existing process_variant_id mechanism
+        # (this assumes the part-catalog → recipe linkage in production; for the test,
+        # we patch the line to point at the recipe directly via x_fc_process_variant_id)
+        self.line.x_fc_process_variant_id = self.recipe.id
+
+        self.so.action_confirm()
+
+        new_job = self.env['fp.job'].search([('sale_order_id', '=', self.so.id)], limit=1)
+        self.assertTrue(new_job, 'Job should have been auto-created')
+        overrides = self.env['fp.job.node.override'].search([
+            ('job_id', '=', new_job.id),
+            ('node_id.default_kind', 'in', ('masking', 'de_masking', 'baking')),
+            ('included', '=', False),
+        ])
+        # Expect 3 opt-outs: mask + de_mask + bake
+        self.assertEqual(len(overrides), 3)
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator,fusion_plating_jobs --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -40
+```
+
+Expected: `len(overrides) == 0` (hook hasn't been wired).
+
+- [ ] **Step 3: Wire the hook**
+
+Edit `fusion_plating_jobs/models/sale_order.py` — find the existing `_fp_auto_create_job` method. At the end (just before `return job`), add:
+
+```python
+        # Express Orders: apply per-line masking / bake overrides
+        # (added 2026-05-26 — see Express Orders spec)
+        if job and job.recipe_id:
+            for line in self.order_line.filtered('x_fc_part_catalog_id'):
+                line._fp_apply_express_overrides_to_job(job)
+```
+
+If `_fp_auto_create_job` produces one job per contributing line (vs. a single consolidated job), adjust the loop accordingly — the helper call is per line, the loop wraps it. Verify the existing function's return shape by reading it first.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_jobs/models/sale_order.py fusion_plating_configurator/tests/test_express_overrides.py
+git commit -m "feat(jobs): hook Express override helper into _fp_auto_create_job"
+```
+
+---
+
+### Task B4: Onchange auto-fill cascade — part-pick seeds Express cells
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_line.py`
+- Create: `fusion_plating_configurator/tests/test_express_onchange_autofill.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_onchange_autofill.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressOnchangeAutofill(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.partner = self.env['res.partner'].create({'name': 'Cust'})
+        self.part = self.env['fp.part.catalog'].create({
+            'partner_id': self.partner.id,
+            'part_number': 'TEST-001',
+            'revision': 'A',
+            'name': 'Test Part',
+            'default_specification_text': 'Per drawing rev A, gloss finish',
+            'default_bake_instructions': '300F x 2hr',
+            'default_masking_enabled': False,
+        })
+        self.wiz = self.env['fp.direct.order.wizard'].create({'partner_id': self.partner.id})
+
+    def test_onchange_seeds_express_fields_from_part_defaults(self):
+        line = self.env['fp.direct.order.line'].new({
+            'wizard_id': self.wiz.id,
+            'part_catalog_id': self.part.id,
+        })
+        line._onchange_part_catalog_id()
+        self.assertEqual(line.line_description, 'Per drawing rev A, gloss finish')
+        self.assertEqual(line.bake_instructions, '300F x 2hr')
+        self.assertFalse(line.masking_enabled)  # part default is False
+```
+
+Wire up in `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --test-enable --test-tags fp_express --stop-after-init 2>&1 | tail -30
+```
+
+Expected: assertions fail (none of the Express fields are seeded by the existing onchange).
+
+- [ ] **Step 3: Extend the onchange**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_line.py` — find the existing `_onchange_part_catalog_id` method. At the end, add:
+
+```python
+        # Express Orders auto-fill (2026-05-26)
+        if self.part_catalog_id:
+            part = self.part_catalog_id
+            # Specification — seed line.line_description from part default (only if line is empty)
+            if not self.line_description and part.default_specification_text:
+                self.line_description = part.default_specification_text
+            # Bake — seed from part default (only if line is empty)
+            if not self.bake_instructions and part.default_bake_instructions:
+                self.bake_instructions = part.default_bake_instructions
+            # Masking — always seed from part default (Boolean is never "empty" — explicit
+            # field exists on the part for this purpose)
+            self.masking_enabled = part.default_masking_enabled
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_line.py fusion_plating_configurator/tests/test_express_onchange_autofill.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): auto-fill Express cells from part defaults on part pick"
+```
+
+---
+
+### Task B5: Carry per-line Express flags to SO line in `_prepare_order_line_vals`
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_line.py`
+- Add a test to `tests/test_express_overrides.py` (or new file)
+
+- [ ] **Step 1: Write the failing test**
+
+Create `tests/test_express_line_to_so.py`:
+
+```python
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressLineToSO(TransactionCase):
+    def test_express_flags_carried_on_confirm(self):
+        partner = self.env['res.partner'].create({'name': 'C'})
+        part = self.env['fp.part.catalog'].create({
+            'partner_id': partner.id, 'part_number': 'X-1', 'revision': 'A',
+            'name': 'X',
+        })
+        wiz = self.env['fp.direct.order.wizard'].create({'partner_id': partner.id})
+        line = self.env['fp.direct.order.line'].create({
+            'wizard_id': wiz.id,
+            'part_catalog_id': part.id,
+            'quantity': 1,
+            'customer_line_ref': 'ABC',
+            'masking_enabled': False,
+            'bake_instructions': '400F x 1hr',
+        })
+
+        vals = line._prepare_order_line_vals()
+        self.assertEqual(vals.get('x_fc_customer_line_ref'), 'ABC')
+        self.assertEqual(vals.get('x_fc_masking_enabled'), False)
+        self.assertEqual(vals.get('x_fc_bake_instructions'), '400F x 1hr')
+```
+
+Wire up in `tests/__init__.py`.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Same command pattern.
+Expected: `KeyError` or all three keys missing from vals.
+
+- [ ] **Step 3: Extend `_prepare_order_line_vals`**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_line.py` — find `_prepare_order_line_vals`. Append to the returned dict:
+
+```python
+        # Express Orders per-line flags
+        vals['x_fc_customer_line_ref'] = self.customer_line_ref or False
+        vals['x_fc_masking_enabled'] = self.masking_enabled
+        vals['x_fc_bake_instructions'] = self.bake_instructions or False
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_line.py fusion_plating_configurator/tests/test_express_line_to_so.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): carry Express line flags through _prepare_order_line_vals"
+```
+
+---
+
+### Task B6: Part-default write-back on confirm
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard.py`
+- Create: `fusion_plating_configurator/tests/test_express_part_writeback.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_part_writeback.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressPartWriteback(TransactionCase):
+    def test_line_values_written_back_to_part_on_confirm(self):
+        partner = self.env['res.partner'].create({'name': 'C'})
+        # Part starts with empty defaults
+        part = self.env['fp.part.catalog'].create({
+            'partner_id': partner.id,
+            'part_number': 'WB-1',
+            'revision': 'A',
+            'name': 'Writeback test',
+        })
+        wiz = self.env['fp.direct.order.wizard'].create({
+            'partner_id': partner.id,
+            'po_pending': True,  # bypass PO requirement
+        })
+        self.env['fp.direct.order.line'].create({
+            'wizard_id': wiz.id,
+            'part_catalog_id': part.id,
+            'quantity': 1,
+            'unit_price': 10,
+            'line_description': 'Per drawing, no contact marks',
+            'bake_instructions': '375F x 3hr',
+            'thickness_range': '.0005-.0010',
+            'masking_enabled': False,
+        })
+        wiz.action_create_order()
+
+        part.invalidate_recordset()
+        self.assertEqual(part.default_specification_text, 'Per drawing, no contact marks')
+        self.assertEqual(part.default_bake_instructions, '375F x 3hr')
+        self.assertEqual(part.x_fc_default_thickness_range, '.0005-.0010')
+        self.assertFalse(part.default_masking_enabled)
+```
+
+Wire up.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Same command.
+Expected: assertions fail — part defaults remain empty.
+
+- [ ] **Step 3: Add the write-back method + invoke from action_create_order**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_wizard.py`. Add the new method:
+
+```python
+    def _fp_writeback_part_defaults(self):
+        """For each line, write back Express values to the part's defaults.
+
+        Single direction (line → part). Editing the part's defaults later
+        does NOT retroactively update existing SO lines (they're frozen at
+        SO confirm).
+        """
+        self.ensure_one()
+        for line in self.line_ids:
+            if not line.part_catalog_id:
+                continue
+            part = line.part_catalog_id
+            wb_vals = {}
+            if line.line_description:
+                wb_vals['default_specification_text'] = line.line_description
+            if line.bake_instructions:
+                wb_vals['default_bake_instructions'] = line.bake_instructions
+            if line.thickness_range:
+                wb_vals['x_fc_default_thickness_range'] = line.thickness_range
+            # Boolean: always write (no notion of "empty" for a Boolean)
+            wb_vals['default_masking_enabled'] = line.masking_enabled
+            if wb_vals:
+                part.write(wb_vals)
+```
+
+Find `action_create_order` and add the call near the end, after the SO has been created (just before `return` or before the state transition):
+
+```python
+        # Write-back per-part defaults (Express Orders — 2026-05-26)
+        self._fp_writeback_part_defaults()
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_wizard.py fusion_plating_configurator/tests/test_express_part_writeback.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): write-back Express line values to part defaults on confirm"
+```
+
+---
+
+### Task B7: `action_open_serial_bulk_add` helpers on line + SO line
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_line.py`
+- Modify: `fusion_plating_configurator/models/sale_order_line.py`
+- Create: `fusion_plating_configurator/tests/test_express_bulk_serial_trigger.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_bulk_serial_trigger.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressBulkSerialTrigger(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.partner = self.env['res.partner'].create({'name': 'C'})
+        self.part = self.env['fp.part.catalog'].create({
+            'partner_id': self.partner.id,
+            'part_number': 'BS-1', 'revision': 'A', 'name': 'BS',
+        })
+
+    def test_line_returns_wizard_action(self):
+        wiz = self.env['fp.direct.order.wizard'].create({'partner_id': self.partner.id})
+        line = self.env['fp.direct.order.line'].create({
+            'wizard_id': wiz.id,
+            'part_catalog_id': self.part.id,
+            'quantity': 5,
+        })
+        action = line.action_open_serial_bulk_add()
+        self.assertEqual(action['res_model'], 'fp.serial.bulk.add.wizard')
+        self.assertEqual(action['context']['default_target_model'], 'fp.direct.order.line')
+        self.assertEqual(action['context']['default_target_id'], line.id)
+        self.assertEqual(action['context']['default_qty_expected'], 5)
+
+    def test_so_line_returns_wizard_action(self):
+        product = self.env['product.product'].search([('default_code', '=', 'FP-SERVICE')], limit=1) \
+            or self.env['product.product'].create({'name': 'svc', 'type': 'service', 'default_code': 'FP-SERVICE'})
+        so = self.env['sale.order'].create({
+            'partner_id': self.partner.id,
+            'order_line': [(0, 0, {'product_id': product.id, 'product_uom_qty': 3})],
+        })
+        line = so.order_line[:1]
+        action = line.action_open_serial_bulk_add()
+        self.assertEqual(action['context']['default_target_model'], 'sale.order.line')
+        self.assertEqual(action['context']['default_target_id'], line.id)
+        self.assertEqual(action['context']['default_qty_expected'], 3)
+```
+
+Wire up.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Same pattern.
+Expected: `AttributeError: action_open_serial_bulk_add`.
+
+- [ ] **Step 3: Implement the helpers**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_line.py` — add:
+
+```python
+    def action_open_serial_bulk_add(self):
+        """Open the existing fp.serial.bulk.add.wizard targeting this line."""
+        self.ensure_one()
+        action = self.env.ref(
+            'fusion_plating_configurator.action_fp_serial_bulk_add_wizard'
+        ).read()[0]
+        action['context'] = {
+            'default_target_model': 'fp.direct.order.line',
+            'default_target_id': self.id,
+            'default_qty_expected': self.quantity,
+        }
+        return action
+```
+
+Edit `fusion_plating_configurator/models/sale_order_line.py` — add the same helper, but with `sale.order.line` target model:
+
+```python
+    def action_open_serial_bulk_add(self):
+        """Open fp.serial.bulk.add.wizard targeting this SO line (post-confirm)."""
+        self.ensure_one()
+        action = self.env.ref(
+            'fusion_plating_configurator.action_fp_serial_bulk_add_wizard'
+        ).read()[0]
+        action['context'] = {
+            'default_target_model': 'sale.order.line',
+            'default_target_id': self.id,
+            'default_qty_expected': self.product_uom_qty,
+        }
+        return action
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_line.py fusion_plating_configurator/models/sale_order_line.py fusion_plating_configurator/tests/test_express_bulk_serial_trigger.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): action_open_serial_bulk_add on line + SO line"
+```
+
+---
+
+### Task B8: `action_upload_drawing` + `action_open_part` helpers
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_line.py`
+- Modify: `fusion_plating_configurator/models/sale_order_line.py`
+- Append to existing `tests/test_express_bulk_serial_trigger.py` (rename file or add new)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/test_express_bulk_serial_trigger.py` (or split into a new file `test_express_part_buttons.py`):
+
+```python
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressPartButtons(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.partner = self.env['res.partner'].create({'name': 'C'})
+        self.part = self.env['fp.part.catalog'].create({
+            'partner_id': self.partner.id,
+            'part_number': 'PB-1', 'revision': 'A', 'name': 'PB',
+        })
+        wiz = self.env['fp.direct.order.wizard'].create({'partner_id': self.partner.id})
+        self.line = self.env['fp.direct.order.line'].create({
+            'wizard_id': wiz.id, 'part_catalog_id': self.part.id, 'quantity': 1,
+        })
+
+    def test_action_open_part_returns_form(self):
+        action = self.line.action_open_part()
+        self.assertEqual(action['res_model'], 'fp.part.catalog')
+        self.assertEqual(action['res_id'], self.part.id)
+        self.assertEqual(action['target'], 'new')
+
+    def test_action_upload_drawing_attaches_to_part(self):
+        # Simulate file picker: pass file data via context
+        import base64
+        fake_pdf = base64.b64encode(b'%PDF-1.4 fake').decode()
+        action = self.line.with_context(
+            fp_drawing_file=fake_pdf,
+            fp_drawing_filename='test.pdf',
+        ).action_upload_drawing()
+        self.assertEqual(action.get('type'), 'ir.actions.client')  # close-and-reload
+        # Check attachment linked
+        self.part.invalidate_recordset()
+        self.assertEqual(len(self.part.drawing_attachment_ids), 1)
+        self.assertEqual(self.part.drawing_attachment_ids[:1].name, 'test.pdf')
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Same pattern.
+Expected: `AttributeError`.
+
+- [ ] **Step 3: Implement the helpers**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_line.py` — add:
+
+```python
+    def action_open_part(self):
+        """Open the linked fp.part.catalog form in a modal (target='new')."""
+        self.ensure_one()
+        if not self.part_catalog_id:
+            return False
+        return {
+            'type': 'ir.actions.act_window',
+            'name': self.part_catalog_id.display_name,
+            'res_model': 'fp.part.catalog',
+            'view_mode': 'form',
+            'res_id': self.part_catalog_id.id,
+            'target': 'new',
+        }
+
+    def action_upload_drawing(self):
+        """Attach a file (passed via context) to the line's part as a drawing.
+
+        Frontend (OWL widget) reads the file picker, base64-encodes, sets
+        context keys fp_drawing_file + fp_drawing_filename, then calls this.
+        """
+        self.ensure_one()
+        if not self.part_catalog_id:
+            raise UserError(_('Pick or create a part on this line first.'))
+        file_data = self.env.context.get('fp_drawing_file')
+        filename = self.env.context.get('fp_drawing_filename', 'drawing.pdf')
+        if not file_data:
+            raise UserError(_('No file data received.'))
+        att = self.env['ir.attachment'].create({
+            'name': filename,
+            'datas': file_data,
+            'res_model': 'fp.part.catalog',
+            'res_id': self.part_catalog_id.id,
+        })
+        self.part_catalog_id.write({
+            'drawing_attachment_ids': [(4, att.id)],
+        })
+        self.part_catalog_id.message_post(body=_(
+            'Drawing "%(name)s" uploaded by %(user)s from line %(line)s on draft %(draft)s.'
+        ) % {
+            'name': filename,
+            'user': self.env.user.display_name,
+            'line': self.sequence or self.id,
+            'draft': self.wizard_id.name,
+        })
+        return {'type': 'ir.actions.client', 'tag': 'reload'}
+```
+
+Mirror the same two methods on `fusion_plating_configurator/models/sale_order_line.py` (similar shape, using `x_fc_part_catalog_id` instead of `part_catalog_id`).
+
+Make sure `UserError` is imported at the top of both files: `from odoo.exceptions import UserError`.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_line.py fusion_plating_configurator/models/sale_order_line.py fusion_plating_configurator/tests/test_express_bulk_serial_trigger.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): action_upload_drawing + action_open_part on line"
+```
+
+---
+
+## Phase C — View XML layer
+
+### Task C1: Currency picker — context-aware `display_name` override
+
+**Files:**
+- Create: `fusion_plating_configurator/models/product_pricelist.py`
+- Modify: `fusion_plating_configurator/models/__init__.py` (add import)
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `tests/test_express_wizard_fields.py`:
+
+```python
+    def test_pricelist_display_name_currency_aware_context(self):
+        # Find or create a pricelist
+        currency_usd = self.env.ref('base.USD')
+        currency_usd.active = True
+        pl = self.env['product.pricelist'].create({
+            'name': 'Test USD Pricelist',
+            'currency_id': currency_usd.id,
+        })
+        # Without context: standard display name
+        self.assertNotIn('USD —', pl.display_name)
+        # With context: currency-prefixed
+        pl_ctx = pl.with_context(fp_express_currency_picker=True)
+        self.assertIn('USD', pl_ctx.display_name)
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Same command.
+Expected: assertion fails (no override yet).
+
+- [ ] **Step 3: Implement the override**
+
+Create `fusion_plating_configurator/models/product_pricelist.py`:
+
+```python
+# -*- coding: utf-8 -*-
+# Copyright 2026 Nexa Systems Inc.
+# Part of the Fusion Plating product family.
+
+from odoo import api, models
+
+
+class ProductPricelist(models.Model):
+    _inherit = 'product.pricelist'
+
+    @api.depends('name', 'currency_id')
+    @api.depends_context('fp_express_currency_picker')
+    def _compute_display_name(self):
+        """Currency-prefixed display in Express Orders picker; standard elsewhere."""
+        super()._compute_display_name()
+        if self.env.context.get('fp_express_currency_picker'):
+            for pl in self:
+                if pl.currency_id:
+                    pl.display_name = f"{pl.currency_id.name} — {pl.name}"
+```
+
+Add to `fusion_plating_configurator/models/__init__.py`:
+
+```python
+from . import product_pricelist
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/models/product_pricelist.py fusion_plating_configurator/models/__init__.py fusion_plating_configurator/tests/test_express_wizard_fields.py
+git commit -m "feat(configurator): context-aware display_name on product.pricelist for currency picker"
+```
+
+---
+
+### Task C2: Quick-create part view (4-field modal)
+
+**Files:**
+- Create: `fusion_plating_configurator/views/fp_part_catalog_quick_create_views.xml`
+- Modify: `fusion_plating_configurator/__manifest__.py` (add to `data`)
+
+- [ ] **Step 1: Create the view file**
+
+`fusion_plating_configurator/views/fp_part_catalog_quick_create_views.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+
+    <record id="view_fp_part_catalog_quick_create_form" model="ir.ui.view">
+        <field name="name">fp.part.catalog.quick.create.form</field>
+        <field name="model">fp.part.catalog</field>
+        <field name="priority">99</field>
+        <field name="arch" type="xml">
+            <form string="Create Part">
+                <sheet>
+                    <group>
+                        <field name="part_number" required="1"
+                               placeholder="ENG-1042"/>
+                        <field name="revision" required="1"
+                               placeholder="A"/>
+                        <field name="name" placeholder="Part description"/>
+                        <field name="partner_id" required="1"
+                               options="{'no_create_edit': True}"
+                               placeholder="Customer"/>
+                    </group>
+                </sheet>
+                <footer>
+                    <button string="Create &amp; Use" type="object"
+                            name="action_quick_create_done"
+                            class="btn-primary"/>
+                    <button string="Cancel" class="btn-secondary"
+                            special="cancel"/>
+                </footer>
+            </form>
+        </field>
+    </record>
+
+    <record id="action_fp_part_catalog_quick_create" model="ir.actions.act_window">
+        <field name="name">Create Part</field>
+        <field name="res_model">fp.part.catalog</field>
+        <field name="view_mode">form</field>
+        <field name="view_id" ref="view_fp_part_catalog_quick_create_form"/>
+        <field name="target">new</field>
+    </record>
+
+</odoo>
+```
+
+- [ ] **Step 2: Add `action_quick_create_done` method on `fp.part.catalog`**
+
+Edit `fusion_plating_configurator/models/fp_part_catalog.py` — add:
+
+```python
+    def action_quick_create_done(self):
+        """Close the quick-create modal and return the new part's id to caller."""
+        self.ensure_one()
+        return {
+            'type': 'ir.actions.act_window_close',
+            'infos': {'created_part_id': self.id},
+        }
+```
+
+The caller (OWL widget on the line) reads `infos.created_part_id` from the close action and assigns it to `part_catalog_id` on the line.
+
+- [ ] **Step 3: Register the view in the manifest**
+
+Edit `fusion_plating_configurator/__manifest__.py` — add to the `data` list (preserve existing entries, just add the new one):
+
+```python
+        'views/fp_part_catalog_quick_create_views.xml',
+```
+
+- [ ] **Step 4: Verify view parses + module reloads**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error" | head -10
+```
+
+Expected: no errors. `Modules loaded.` at the end.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/views/fp_part_catalog_quick_create_views.xml fusion_plating_configurator/models/fp_part_catalog.py fusion_plating_configurator/__manifest__.py
+git commit -m "feat(configurator): 4-field quick-create view for fp.part.catalog"
+```
+
+---
+
+### Task C3: SCSS tokens + base styles (light + dark)
+
+**Files:**
+- Create: `fusion_plating_configurator/static/src/scss/_express_tokens.scss`
+- Create: `fusion_plating_configurator/static/src/scss/express_order.scss`
+- Modify: `fusion_plating_configurator/__manifest__.py` (add `assets`)
+
+- [ ] **Step 1: Create token file (loads FIRST in bundle)**
+
+`fusion_plating_configurator/static/src/scss/_express_tokens.scss`:
+
+```scss
+// Express Orders colour tokens — compile-time dark-mode branch
+// per Odoo 19 convention (see CLAUDE.md "Dark Mode" section).
+
+$o-webclient-color-scheme: bright !default;
+
+$_xpr-page-hex:        #f3f4f6;
+$_xpr-card-hex:        #ffffff;
+$_xpr-card-soft-hex:   #fafafa;
+$_xpr-border-hex:      #e5e7eb;
+$_xpr-border-strong-hex: #d1d5db;
+$_xpr-text-hex:        #1f2937;
+$_xpr-text-muted-hex:  #6b7280;
+$_xpr-text-dim-hex:    #9ca3af;
+$_xpr-accent-hex:      #714b67;
+$_xpr-accent-bg-hex:   #faf5f8;
+$_xpr-focus-hex:       #fef9e7;
+$_xpr-good-hex:        #059669;
+$_xpr-bad-hex:         #dc2626;
+
+@if $o-webclient-color-scheme == dark {
+    $_xpr-page-hex:        #1a1d21 !global;
+    $_xpr-card-hex:        #22262d !global;
+    $_xpr-card-soft-hex:   #1e2128 !global;
+    $_xpr-border-hex:      #374151 !global;
+    $_xpr-border-strong-hex: #4b5563 !global;
+    $_xpr-text-hex:        #e5e7eb !global;
+    $_xpr-text-muted-hex:  #9ca3af !global;
+    $_xpr-text-dim-hex:    #6b7280 !global;
+    $_xpr-accent-hex:      #b88fb5 !global;
+    $_xpr-accent-bg-hex:   #2d2330 !global;
+    $_xpr-focus-hex:       #3d3920 !global;
+    $_xpr-good-hex:        #34d399 !global;
+    $_xpr-bad-hex:         #f87171 !global;
+}
+
+$xpr-page:          var(--xpr-page-bg, $_xpr-page-hex);
+$xpr-card:          var(--xpr-card-bg, $_xpr-card-hex);
+$xpr-card-soft:     var(--xpr-card-soft-bg, $_xpr-card-soft-hex);
+$xpr-border:        var(--xpr-border, $_xpr-border-hex);
+$xpr-border-strong: var(--xpr-border-strong, $_xpr-border-strong-hex);
+$xpr-text:          var(--xpr-text, $_xpr-text-hex);
+$xpr-text-muted:    var(--xpr-text-muted, $_xpr-text-muted-hex);
+$xpr-text-dim:      var(--xpr-text-dim, $_xpr-text-dim-hex);
+$xpr-accent:        var(--xpr-accent, $_xpr-accent-hex);
+$xpr-accent-bg:     var(--xpr-accent-bg, $_xpr-accent-bg-hex);
+$xpr-focus:         var(--xpr-focus, $_xpr-focus-hex);
+$xpr-good:          var(--xpr-good, $_xpr-good-hex);
+$xpr-bad:           var(--xpr-bad, $_xpr-bad-hex);
+```
+
+- [ ] **Step 2: Create main stylesheet**
+
+`fusion_plating_configurator/static/src/scss/express_order.scss`:
+
+```scss
+// Express Orders — main stylesheet
+// Tokens are loaded FIRST via the manifest, so $xpr-* are in scope.
+
+.o_fp_express_order {
+    background: $xpr-page;
+    color: $xpr-text;
+
+    // Part cell — multi-row stacked
+    .o_fp_part_cell {
+        display: flex;
+        flex-direction: column;
+        gap: 0;
+        min-width: 210px;
+
+        & > div {
+            padding: 5px 8px;
+        }
+        & > div:not(:last-child) {
+            border-bottom: 1px solid $xpr-border;
+        }
+        .o_fp_part_id {
+            display: flex; align-items: baseline; gap: 4px;
+            font-weight: 600;
+            .o_fp_sep { color: $xpr-text-dim; font-weight: 400; padding: 0 4px; }
+        }
+        .o_fp_part_name input { font-style: italic; font-size: 12px; }
+        .o_fp_part_serial input { font-size: 11px; color: $xpr-text-muted; }
+    }
+
+    // Bake pill
+    .o_fp_bake_pill {
+        display: inline-flex; align-items: center;
+        padding: 2px 10px; border-radius: 3px;
+        font-size: 12px; font-weight: 500;
+        border: 1px solid $xpr-border-strong;
+        cursor: pointer;
+        background: $xpr-card;
+        color: $xpr-text;
+
+        &.has-bake {
+            background: rgba(251, 146, 60, 0.15);
+            color: #c2410c;
+            border-color: #fb923c;
+        }
+        &.no-bake {
+            background: $xpr-card-soft;
+            color: $xpr-text-muted;
+            font-style: italic;
+        }
+    }
+
+    // Line number / drag handle hover swap
+    .o_fp_row_handle {
+        text-align: center;
+        .o_fp_row_num { color: $xpr-text-dim; font-weight: 700; font-size: 11px; }
+        .o_fp_row_grip { display: none; cursor: grab; color: $xpr-text-dim; }
+    }
+    .o_list_view tbody tr:hover .o_fp_row_handle {
+        .o_fp_row_num { display: none; }
+        .o_fp_row_grip { display: inline-block; }
+    }
+}
+```
+
+- [ ] **Step 3: Register assets in the manifest**
+
+Edit `fusion_plating_configurator/__manifest__.py` — add (if `assets` doesn't exist) or extend an existing `assets` block:
+
+```python
+    'assets': {
+        'web.assets_backend': [
+            'fusion_plating_configurator/static/src/scss/_express_tokens.scss',
+            'fusion_plating_configurator/static/src/scss/express_order.scss',
+        ],
+    },
+```
+
+**Important** — tokens MUST load FIRST. Odoo concatenates SCSS files in manifest order; `_express_tokens.scss` declares the variables, `express_order.scss` consumes them.
+
+- [ ] **Step 4: Verify SCSS compiles**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "scss|sass|error" | head -10
+```
+
+Expected: no SCSS errors. (Visual check happens in Phase E once views render.)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/static/src/scss/ fusion_plating_configurator/__manifest__.py
+git commit -m "feat(configurator): Express SCSS tokens + base styles (light + dark)"
+```
+
+---
+
+### Task C4: OWL widget — `FpExpressPartCell` (multi-row Part cell)
+
+**Files:**
+- Create: `fusion_plating_configurator/static/src/js/express_part_cell.js`
+- Create: `fusion_plating_configurator/static/src/xml/express_part_cell.xml`
+- Modify: `fusion_plating_configurator/__manifest__.py` (add to assets)
+
+- [ ] **Step 1: Create the OWL component**
+
+`fusion_plating_configurator/static/src/js/express_part_cell.js`:
+
+```javascript
+/** @odoo-module **/
+import { Component } from "@odoo/owl";
+import { registry } from "@web/core/registry";
+import { standardFieldProps } from "@web/views/fields/standard_field_props";
+import { Many2OneField } from "@web/views/fields/many2one/many2one_field";
+import { useService } from "@web/core/utils/hooks";
+
+export class FpExpressPartCell extends Component {
+    static template = "fusion_plating_configurator.FpExpressPartCell";
+    static props = ["*"];
+    static components = { Many2OneField };
+
+    setup() {
+        this.action = useService("action");
+    }
+
+    get partName() {
+        return this.props.record.data.part_catalog_id?.[1] || "";
+    }
+    get partNumber() {
+        const part = this.props.record.data.part_catalog_id;
+        return part ? part[1].split(" Rev ")[0] : "";
+    }
+    get revision() {
+        return this.props.record.data.revision || "";
+    }
+    get serialDisplay() {
+        const serials = this.props.record.data.serial_ids?.records || [];
+        return serials.map(s => s.data.name).join(", ");
+    }
+
+    async onBulkAddClick() {
+        const recordId = this.props.record.resId;
+        if (!recordId) return;
+        const action = await this.env.services.orm.call(
+            this.props.record.resModel,
+            "action_open_serial_bulk_add",
+            [[recordId]],
+        );
+        this.action.doAction(action);
+    }
+}
+
+registry.category("fields").add("fp_express_part_cell", {
+    component: FpExpressPartCell,
+    supportedTypes: ["many2one"],
+});
+```
+
+- [ ] **Step 2: Create the template**
+
+`fusion_plating_configurator/static/src/xml/express_part_cell.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<templates xml:space="preserve">
+
+<t t-name="fusion_plating_configurator.FpExpressPartCell">
+    <div class="o_fp_part_cell">
+        <div class="o_fp_part_id">
+            <Many2OneField
+                record="props.record"
+                name="'part_catalog_id'"
+                readonly="false"/>
+            <span class="o_fp_sep">/</span>
+            <span><t t-esc="revision"/></span>
+        </div>
+        <div class="o_fp_part_name">
+            <span t-esc="partName"/>
+        </div>
+        <div class="o_fp_part_serial">
+            <span t-esc="serialDisplay or 'no serials yet'"/>
+            <button class="btn btn-sm btn-link"
+                    t-on-click="onBulkAddClick"
+                    title="Bulk add serials">+ bulk</button>
+        </div>
+    </div>
+</t>
+
+</templates>
+```
+
+- [ ] **Step 3: Register assets in the manifest**
+
+Extend the `assets` block in `__manifest__.py`:
+
+```python
+    'assets': {
+        'web.assets_backend': [
+            'fusion_plating_configurator/static/src/scss/_express_tokens.scss',
+            'fusion_plating_configurator/static/src/scss/express_order.scss',
+            'fusion_plating_configurator/static/src/js/express_part_cell.js',
+            'fusion_plating_configurator/static/src/xml/express_part_cell.xml',
+        ],
+    },
+```
+
+- [ ] **Step 4: Verify module reloads + widget registers**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error" | head -10
+```
+
+Expected: no errors.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/static/src/js/express_part_cell.js fusion_plating_configurator/static/src/xml/express_part_cell.xml fusion_plating_configurator/__manifest__.py
+git commit -m "feat(configurator): OWL widget FpExpressPartCell (multi-row part cell)"
+```
+
+---
+
+### Task C5: OWL widget — `FpExpressBakePill` (click-to-edit)
+
+**Files:**
+- Create: `fusion_plating_configurator/static/src/js/express_bake_pill.js`
+- Create: `fusion_plating_configurator/static/src/xml/express_bake_pill.xml`
+- Modify: `__manifest__.py`
+
+- [ ] **Step 1: Create the OWL component**
+
+`fusion_plating_configurator/static/src/js/express_bake_pill.js`:
+
+```javascript
+/** @odoo-module **/
+import { Component, useState } from "@odoo/owl";
+import { registry } from "@web/core/registry";
+
+export class FpExpressBakePill extends Component {
+    static template = "fusion_plating_configurator.FpExpressBakePill";
+    static props = ["*"];
+
+    setup() {
+        this.state = useState({
+            editing: false,
+            draft: this.value,
+        });
+    }
+    get value() {
+        return this.props.record.data[this.props.name] || "";
+    }
+    get hasBake() {
+        return !!(this.value && this.value.trim());
+    }
+    get pillLabel() {
+        return this.hasBake ? this.value : "no bake";
+    }
+
+    openEditor() {
+        this.state.draft = this.value;
+        this.state.editing = true;
+    }
+    save() {
+        this.props.record.update({ [this.props.name]: this.state.draft || false });
+        this.state.editing = false;
+    }
+    clear() {
+        this.props.record.update({ [this.props.name]: false });
+        this.state.draft = "";
+        this.state.editing = false;
+    }
+    cancel() {
+        this.state.editing = false;
+    }
+}
+
+registry.category("fields").add("fp_express_bake_pill", {
+    component: FpExpressBakePill,
+    supportedTypes: ["text"],
+});
+```
+
+- [ ] **Step 2: Create the template**
+
+`fusion_plating_configurator/static/src/xml/express_bake_pill.xml`:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<templates xml:space="preserve">
+
+<t t-name="fusion_plating_configurator.FpExpressBakePill">
+    <t t-if="!state.editing">
+        <span class="o_fp_bake_pill"
+              t-att-class="{ 'has-bake': hasBake, 'no-bake': !hasBake }"
+              t-on-click="openEditor"
+              t-esc="pillLabel"/>
+    </t>
+    <t t-else="">
+        <div class="o_fp_bake_pill_editor">
+            <textarea t-model="state.draft" rows="2"
+                      placeholder="e.g. 350F x 4hr"/>
+            <div>
+                <button class="btn btn-sm btn-primary" t-on-click="save">Save</button>
+                <button class="btn btn-sm btn-secondary" t-on-click="clear">Clear</button>
+                <button class="btn btn-sm btn-link" t-on-click="cancel">Cancel</button>
+            </div>
+        </div>
+    </t>
+</t>
+
+</templates>
+```
+
+- [ ] **Step 3: Register in manifest**
+
+Add to `assets.web.assets_backend`:
+
+```python
+            'fusion_plating_configurator/static/src/js/express_bake_pill.js',
+            'fusion_plating_configurator/static/src/xml/express_bake_pill.xml',
+```
+
+- [ ] **Step 4: Verify reload**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error" | head -10
+```
+
+Expected: clean.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/static/src/js/express_bake_pill.js fusion_plating_configurator/static/src/xml/express_bake_pill.xml fusion_plating_configurator/__manifest__.py
+git commit -m "feat(configurator): OWL widget FpExpressBakePill (click-to-edit bake pill)"
+```
+
+---
+
+### Task C6: Express form view — header + lines + footer
+
+This is the big view file. Single task, but the body is substantial. The view extends `view_fp_direct_order_wizard_form` is **not** the right approach — Express is a fresh view that targets the same model with a different layout. So this is a new `<record>` not an inheritance.
+
+**Files:**
+- Create: `fusion_plating_configurator/views/fp_express_order_views.xml`
+- Modify: `__manifest__.py` (add to `data`)
+
+- [ ] **Step 1: Create the Express form view**
+
+`fusion_plating_configurator/views/fp_express_order_views.xml` (full file — paste verbatim):
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo>
+
+    <record id="view_fp_express_order_form" model="ir.ui.view">
+        <field name="name">fp.express.order.form</field>
+        <field name="model">fp.direct.order.wizard</field>
+        <field name="priority">10</field>
+        <field name="arch" type="xml">
+            <form string="Express Order Entry" class="o_fp_express_order">
+                <header>
+                    <button name="action_create_order" type="object"
+                            string="Confirm Order"
+                            class="btn-primary"
+                            invisible="state != 'draft'"/>
+                    <button name="action_view_sale_order" type="object"
+                            string="Open Sale Order"
+                            class="btn-primary"
+                            invisible="state != 'confirmed' or not sale_order_id"/>
+                    <button name="action_switch_to_legacy" type="object"
+                            string="Switch to Legacy View"
+                            class="btn-secondary"
+                            invisible="state != 'draft'"/>
+                    <field name="state" widget="statusbar"
+                           statusbar_visible="draft,confirmed"/>
+                </header>
+                <sheet>
+                    <div class="oe_title">
+                        <h1><field name="name" readonly="1"/></h1>
+                    </div>
+
+                    <!-- Header grid: Customer + Shipping (row 1), PO block + Job # + Sort (row 2), etc. -->
+                    <group>
+                        <group string="Customer">
+                            <field name="partner_id" options="{'no_create_edit': True}"/>
+                            <field name="partner_shipping_id"
+                                   options="{'no_create_edit': False}"
+                                   invisible="not partner_id"/>
+                            <field name="customer_job_number"/>
+                            <field name="job_sort_id"
+                                   options="{'no_create_edit': False, 'no_open': True}"
+                                   placeholder="Type to create a new bucket..."/>
+                            <field name="material_process" placeholder="ENP-STEEL-HP-ADVANCED"/>
+                        </group>
+                        <group string="Purchase Order">
+                            <field name="po_number"
+                                   placeholder="Enter the customer PO number"/>
+                            <field name="po_attachment_file"
+                                   filename="po_attachment_filename"/>
+                            <field name="po_attachment_filename" invisible="1"/>
+                            <field name="po_pending" widget="boolean_toggle"/>
+                            <field name="po_expected_date"
+                                   invisible="not po_pending"/>
+                        </group>
+                    </group>
+
+                    <group>
+                        <group string="Scheduling &amp; Lead Time">
+                            <label for="lead_time_min_days" string="Lead Time (days)"/>
+                            <div class="o_row">
+                                <field name="lead_time_min_days" class="oe_inline" style="width: 4em;"/>
+                                <span> to </span>
+                                <field name="lead_time_max_days" class="oe_inline" style="width: 4em;"/>
+                            </div>
+                            <field name="customer_deadline" string="Delivery Date"/>
+                            <field name="validity_date" string="Quote Validity"/>
+                            <field name="is_blanket_order"/>
+                        </group>
+                        <group string="Pricing &amp; Fulfilment">
+                            <field name="pricelist_id"
+                                   string="Currency / Pricelist"
+                                   context="{'fp_express_currency_picker': True}"
+                                   options="{'no_create_edit': True}"/>
+                            <field name="payment_term_id"
+                                   options="{'no_create': True}"/>
+                            <field name="delivery_method"/>
+                            <field name="invoice_strategy"/>
+                        </group>
+                    </group>
+
+                    <notebook>
+                        <page string="Lines" name="lines">
+                            <field name="line_ids">
+                                <list editable="bottom"
+                                      decoration-warning="is_missing_info">
+                                    <field name="is_missing_info" column_invisible="1"/>
+                                    <field name="sequence" widget="handle"/>
+                                    <field name="part_catalog_id"
+                                           widget="fp_express_part_cell"
+                                           context="{'default_partner_id': parent.partner_id, 'default_revision': 'A'}"
+                                           domain="[('partner_id', '=', parent.partner_id), ('is_latest_revision', '=', True)]"/>
+                                    <field name="line_description" string="Specification"/>
+                                    <field name="customer_line_ref" string="Line Job #"/>
+                                    <field name="thickness_range" placeholder="e.g. .0005-.0010"/>
+                                    <field name="masking_enabled" widget="boolean_toggle"/>
+                                    <field name="bake_instructions" widget="fp_express_bake_pill"/>
+                                    <field name="internal_description" string="Internal Notes"/>
+                                    <field name="quantity"/>
+                                    <field name="unit_price"
+                                           widget="monetary"
+                                           options="{'currency_field': 'currency_id'}"/>
+                                    <field name="line_subtotal"
+                                           widget="monetary"
+                                           options="{'currency_field': 'currency_id'}"
+                                           sum="Total"/>
+                                    <button name="action_upload_drawing" type="object"
+                                            string="DWG" class="btn-link"
+                                            invisible="not part_catalog_id"/>
+                                    <button name="action_open_part" type="object"
+                                            string="OPEN" class="btn-link"
+                                            invisible="not part_catalog_id"/>
+                                    <field name="currency_id" column_invisible="1"/>
+                                </list>
+                            </field>
+                            <group class="mt-3">
+                                <group>
+                                    <field name="total_line_count" readonly="1"/>
+                                    <field name="total_qty" readonly="1"/>
+                                </group>
+                                <group>
+                                    <field name="total_amount"
+                                           widget="monetary"
+                                           options="{'currency_field': 'currency_id'}"
+                                           readonly="1"/>
+                                </group>
+                            </group>
+                        </page>
+                        <page string="Notes &amp; Terms" name="notes">
+                            <group>
+                                <group string="Order-Level Internal Notes (never prints)">
+                                    <field name="internal_notes" nolabel="1"
+                                           placeholder="Visible only to estimator / planner / shop."/>
+                                </group>
+                                <group string="Terms &amp; Conditions (prints on customer docs)">
+                                    <field name="terms_and_conditions" nolabel="1"/>
+                                </group>
+                            </group>
+                        </page>
+                    </notebook>
+
+                </sheet>
+                <chatter/>
+            </form>
+        </field>
+    </record>
+
+    <record id="action_fp_express_order" model="ir.actions.act_window">
+        <field name="name">+ New Express Order</field>
+        <field name="res_model">fp.direct.order.wizard</field>
+        <field name="view_mode">form</field>
+        <field name="view_id" ref="view_fp_express_order_form"/>
+        <field name="target">current</field>
+        <field name="context">{'default_view_source': 'express'}</field>
+    </record>
+
+    <menuitem id="menu_fp_express_order"
+              name="+ New Express Order"
+              parent="fusion_plating_configurator.menu_fp_sales_quoting"
+              action="action_fp_express_order"
+              sequence="2"/>
+
+</odoo>
+```
+
+- [ ] **Step 2: Add `action_switch_to_legacy` method**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_wizard.py` — add:
+
+```python
+    def action_switch_to_legacy(self):
+        """Re-open this draft in the legacy view."""
+        self.ensure_one()
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'fp.direct.order.wizard',
+            'res_id': self.id,
+            'view_mode': 'form',
+            'view_id': self.env.ref(
+                'fusion_plating_configurator.view_fp_direct_order_wizard_form'
+            ).id,
+            'target': 'current',
+        }
+```
+
+Also add the mirror `action_switch_to_express` (for the legacy view to call):
+
+```python
+    def action_switch_to_express(self):
+        """Re-open this draft in the Express view."""
+        self.ensure_one()
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'fp.direct.order.wizard',
+            'res_id': self.id,
+            'view_mode': 'form',
+            'view_id': self.env.ref(
+                'fusion_plating_configurator.view_fp_express_order_form'
+            ).id,
+            'target': 'current',
+        }
+```
+
+- [ ] **Step 3: Register the view in the manifest**
+
+Add to `__manifest__.py` `data` (after the quick-create view registered in Task C2):
+
+```python
+        'views/fp_express_order_views.xml',
+```
+
+Confirm the menu parent `fusion_plating_configurator.menu_fp_sales_quoting` exists by greping. If the menu xmlid is different, adjust to match the existing parent.
+
+- [ ] **Step 4: Verify view loads + menu appears**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error|warning" | head -20
+```
+
+Expected: clean. Open `http://localhost:8069/web` → Plating → Sales & Quoting → "+ New Express Order" should appear.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add fusion_plating_configurator/views/fp_express_order_views.xml fusion_plating_configurator/wizard/fp_direct_order_wizard.py fusion_plating_configurator/__manifest__.py
+git commit -m "feat(configurator): Express Orders form view + action + menu item"
+```
+
+---
+
+## Phase D — Drafts list + view switching
+
+### Task D1: Drafts list `view_source` badge column + dual-routing
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard_views.xml`
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard.py` (add `action_open_draft`)
+- Create: `fusion_plating_configurator/tests/test_express_drafts_routing.py`
+
+- [ ] **Step 1: Write the failing test**
+
+```python
+# tests/test_express_drafts_routing.py
+from odoo.tests.common import TransactionCase, tagged
+
+
+@tagged('post_install', '-at_install', 'fp_express')
+class TestExpressDraftsRouting(TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.partner = self.env['res.partner'].create({'name': 'C'})
+
+    def test_express_draft_routes_to_express_view(self):
+        wiz = self.env['fp.direct.order.wizard'].create({
+            'partner_id': self.partner.id, 'view_source': 'express',
+        })
+        action = wiz.action_open_draft()
+        expected = self.env.ref('fusion_plating_configurator.view_fp_express_order_form').id
+        self.assertEqual(action['view_id'], expected)
+
+    def test_legacy_draft_routes_to_legacy_view(self):
+        wiz = self.env['fp.direct.order.wizard'].create({
+            'partner_id': self.partner.id, 'view_source': 'legacy',
+        })
+        action = wiz.action_open_draft()
+        expected = self.env.ref('fusion_plating_configurator.view_fp_direct_order_wizard_form').id
+        self.assertEqual(action['view_id'], expected)
+```
+
+Wire up.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Same command.
+Expected: `AttributeError: action_open_draft`.
+
+- [ ] **Step 3: Implement `action_open_draft`**
+
+Add to `fusion_plating_configurator/wizard/fp_direct_order_wizard.py`:
+
+```python
+    def action_open_draft(self):
+        """Route the drafts-list row-click to the form view matching view_source."""
+        self.ensure_one()
+        view_xmlid = (
+            'fusion_plating_configurator.view_fp_express_order_form'
+            if self.view_source == 'express'
+            else 'fusion_plating_configurator.view_fp_direct_order_wizard_form'
+        )
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'fp.direct.order.wizard',
+            'res_id': self.id,
+            'view_mode': 'form',
+            'view_id': self.env.ref(view_xmlid).id,
+            'target': 'current',
+        }
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Same command.
+Expected: `OK`.
+
+- [ ] **Step 5: Add `view_source` badge column to the drafts list**
+
+Edit `fusion_plating_configurator/wizard/fp_direct_order_wizard_views.xml` — find the `view_fp_direct_order_wizard_list` record and add a new field inside `<list>`:
+
+```xml
+                <field name="view_source" widget="badge"
+                       decoration-info="view_source == 'express'"
+                       decoration-muted="view_source == 'legacy'"
+                       optional="show"/>
+```
+
+Also change the list's row-click to route via the method:
+
+```xml
+            <list ...
+                  default_order="create_date desc"
+                  action="action_open_draft"
+                  type="object">
+```
+
+(Standard Odoo list view supports `action="..."` + `type="object"` to override the row-click target.)
+
+- [ ] **Step 6: Verify view loads**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error" | head -10
+```
+
+Expected: clean.
+
+- [ ] **Step 7: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_wizard.py fusion_plating_configurator/wizard/fp_direct_order_wizard_views.xml fusion_plating_configurator/tests/test_express_drafts_routing.py fusion_plating_configurator/tests/__init__.py
+git commit -m "feat(configurator): drafts list view_source badge + dual-routing click action"
+```
+
+---
+
+### Task D2: Phase 2 deprecation banner on legacy view
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard_views.xml`
+
+This task is shipped LATER (Phase 2, ~Week 3 after launch). Tracking here for completeness so the writing-plans output captures the full timeline.
+
+- [ ] **Step 1: Add the banner**
+
+Find the legacy form's `<sheet>` opening tag in `view_fp_direct_order_wizard_form`. Just before it, add:
+
+```xml
+                <div class="alert alert-warning py-2 mb-0 small"
+                     role="alert">
+                    <i class="fa fa-exclamation-triangle me-1"/>
+                    <strong>Legacy view.</strong> This form is being retired
+                    in favour of the new Express Orders view, which is faster
+                    for batch entry.
+                    <button name="action_switch_to_express" type="object"
+                            string="Switch to Express ➜"
+                            class="btn-link btn-sm py-0"/>
+                </div>
+```
+
+- [ ] **Step 2: Verify view loads + banner appears**
+
+```bash
+docker exec odoo-dev-app odoo -c /etc/odoo/odoo.conf -d fusion-dev -u fusion_plating_configurator --stop-after-init 2>&1 | grep -iE "error" | head -10
+```
+
+Expected: clean. Manually verify banner appears on the legacy form.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add fusion_plating_configurator/wizard/fp_direct_order_wizard_views.xml
+git commit -m "feat(configurator): Phase 2 deprecation banner on legacy direct-order view"
+```
+
+---
+
+## Phase E — Smoke test runbook
+
+### Task E1: End-to-end smoke test
+
+This is a manual checklist, not an automated test. Run after all Phase A–D tasks pass on local dev.
+
+**Files:**
+- Create: `fusion_plating_configurator/docs/express_orders_smoke_test.md` (in-repo runbook)
+
+- [ ] **Step 1: Create the runbook**
+
+`fusion_plating_configurator/docs/express_orders_smoke_test.md`:
+
+```markdown
+# Express Orders — Smoke Test Runbook
+
+Run after deploy to confirm end-to-end flow. ~10 minutes.
+
+## Setup
+
+1. Open http://localhost:8069/web → Plating → Sales & Quoting → **+ New Express Order**
+2. Confirm the form opens with the Express layout (NOT the legacy form)
+
+## Test 1 — Happy path with mask + bake
+
+1. Pick customer "WESTIN HEALTHCARE INC."
+2. Confirm `partner_shipping_id` defaults to the customer's first address
+3. Confirm `pricelist_id` defaults to the customer's default pricelist
+4. Type PO# "PO-SMOKE-01"
+5. Upload any PDF as the PO attachment
+6. Add a line — pick part "ENG-1042 Rev B" (or create one via the inline + Create modal)
+7. Confirm auto-fill: description, thickness, masking checkbox, bake pill all populate from part defaults
+8. Set quantity 5, price 42.00
+9. Click "Confirm Order"
+10. Expected:
+    - SO is created
+    - `fp.job` row exists for the SO
+    - Job's recipe is the one linked to the part
+    - No `fp.job.node.override` rows (masking on, bake non-empty)
+    - Bake step's `instructions` field shows the bake text
+    - Job chatter has the audit post: "Bake step instructions set to: ..."
+
+## Test 2 — Masking opt-out
+
+1. Repeat Test 1 but uncheck the masking checkbox before confirming
+2. Expected:
+    - `fp.job.node.override` rows exist with `included=False` for masking AND de_masking nodes
+    - Job chatter audit: "Masking + de-masking steps opted out (per SO line)"
+
+## Test 3 — Bake opt-out
+
+1. Repeat Test 1 but clear the bake pill (set to "no bake") before confirming
+2. Expected:
+    - `fp.job.node.override` row exists with `included=False` for baking node
+    - Job chatter audit: "Baking steps opted out (per SO line)"
+
+## Test 4 — Bulk-add serials
+
+1. On a line, click the `+ bulk` button on the serial row
+2. Bulk-add wizard opens
+3. Switch to Range Fill mode, prefix SN-, start 1, end 5
+4. Click Add Serials
+5. Expected: line's `serial_ids` populated with SN-001 … SN-005
+
+## Test 5 — DWG / OPEN buttons
+
+1. On a line with a part selected, click DWG → upload a PDF
+2. Expected: file attaches to `part.drawing_attachment_ids`, button shows updated count
+3. Click OPEN
+4. Expected: part form opens in a modal
+
+## Test 6 — Currency switch
+
+1. On a draft, change the pricelist from CAD to a USD pricelist
+2. Confirm prompt: "Update Prices?" → click Yes
+3. Expected: line `unit_price` values are recomputed in USD; currency pill on Grand Total flips to USD
+
+## Test 7 — Round-trip with legacy view
+
+1. Create a draft in Express view, save (no confirm)
+2. Go to "Direct Order Drafts" list
+3. Confirm the draft shows badge "Express"
+4. Open the draft → confirms Express view loads
+5. Click "Switch to Legacy View" header button
+6. Confirm same data renders in the legacy form
+7. Go back to drafts list, click the row → still routes to Express (because view_source='express')
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add fusion_plating_configurator/docs/
+git commit -m "docs(configurator): Express Orders smoke test runbook"
+```
+
+---
+
+## Phase F — Deferred: Phase 3 & 4 (post-launch)
+
+These two tasks ship LATER (Weeks 4–5+ after launch). Captured here so the plan is complete.
+
+### Task F1 (Phase 3, Week 4): Hide legacy menu + auto-redirect
+
+**Files:**
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard_views.xml`
+- Modify: `fusion_plating_configurator/wizard/fp_direct_order_wizard.py`
+
+Steps:
+1. Add `groups="base.group_no_one"` (debug-mode-only) to the `+ New Direct Order` menuitem so it's hidden in normal mode.
+2. Patch `action_open_draft` to ALWAYS return the Express view:
+
+```python
+    def action_open_draft(self):
+        self.ensure_one()
+        # Phase 3 (2026-XX-XX): all drafts auto-route to Express
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'fp.direct.order.wizard',
+            'res_id': self.id,
+            'view_mode': 'form',
+            'view_id': self.env.ref(
+                'fusion_plating_configurator.view_fp_express_order_form'
+            ).id,
+            'target': 'current',
+        }
+```
+
+3. Bump module version (e.g. 19.0.23.0.0).
+4. Commit: `chore(configurator): Phase 3 — hide legacy menu, auto-redirect drafts`
+
+### Task F2 (Phase 4, Week 5+): Full removal
+
+**Files:**
+- Delete: `view_fp_direct_order_wizard_form` record
+- Delete: `action_fp_direct_order_wizard` record
+- Delete: `+ New Direct Order` menuitem
+- Create: `fusion_plating_configurator/migrations/19.0.24.0.0/post-migrate.py`
+
+The post-migration:
+
+```python
+def migrate(cr, version):
+    # 1. Drop the view_source column (no longer used)
+    cr.execute("ALTER TABLE fp_direct_order_wizard DROP COLUMN IF EXISTS view_source")
+
+    # 2. Sweep orphan landing actions — any user whose landing pointed at the
+    # retired legacy action gets re-pointed at the Express action.
+    cr.execute("""
+        UPDATE res_users
+        SET x_fc_plating_landing_action_id = (
+            SELECT res_id FROM ir_model_data
+            WHERE module = 'fusion_plating_configurator'
+              AND name = 'action_fp_express_order'
+              AND model = 'ir.actions.act_window'
+            LIMIT 1
+        )
+        WHERE x_fc_plating_landing_action_id IN (
+            SELECT res_id FROM ir_model_data
+            WHERE module = 'fusion_plating_configurator'
+              AND name = 'action_fp_direct_order_wizard'
+              AND model = 'ir.actions.act_window'
+        )
+    """)
+```
+
+Also remove `view_source` field from the model definition. Commit: `chore(configurator): Phase 4 — remove legacy direct-order view + view_source column`
+
+---
+
+## Self-Review
+
+**Spec coverage check** — every NEW field + helper + view + button from the spec has a task above:
+
+- `fp.part.catalog.default_specification_text/default_bake_instructions/default_masking_enabled` → A1 ✓
+- `fp.direct.order.line.customer_line_ref/masking_enabled/bake_instructions` → A2 ✓
+- `sale.order.line.x_fc_*` (3 fields) → A3 ✓
+- `sale.order.x_fc_material_process/x_fc_internal_notes/x_fc_print_terms` → A4 ✓
+- `fp.direct.order.wizard.material_process/pricelist_id/validity_date/internal_notes/terms_and_conditions/view_source` + rename notes + retire currency_id → A5 ✓
+- `_fp_all_nodes_with_kind` helper → B1 ✓
+- `_fp_apply_express_overrides_to_job` helper + 4 quadrants + audit + idempotency → B2 ✓
+- Hook into `_fp_auto_create_job` → B3 ✓
+- Onchange auto-fill cascade → B4 ✓
+- `_prepare_order_line_vals` carry-through → B5 ✓
+- Part-default write-back on confirm → B6 ✓
+- `action_open_serial_bulk_add` → B7 ✓
+- `action_upload_drawing` + `action_open_part` → B8 ✓
+- Currency picker context-aware display_name → C1 ✓
+- Quick-create part view → C2 ✓
+- SCSS tokens + light/dark → C3 ✓
+- OWL widget FpExpressPartCell → C4 ✓
+- OWL widget FpExpressBakePill → C5 ✓
+- Express form view + menu + action + `action_switch_to_legacy`/`action_switch_to_express` → C6 ✓
+- Drafts list dual-routing + badge → D1 ✓
+- Phase 2 deprecation banner → D2 ✓
+- Smoke test runbook → E1 ✓
+- Phase 3 + 4 deferred tasks → F1, F2 ✓
+
+**No placeholder check** — all steps have concrete code, exact file paths, and runnable commands.
+
+**Type consistency** — method names verified consistent: `_fp_apply_express_overrides_to_job`, `_fp_all_nodes_with_kind`, `action_open_serial_bulk_add`, `action_upload_drawing`, `action_open_part`, `action_open_draft`, `action_switch_to_legacy`, `action_switch_to_express`, `action_quick_create_done`. Field names verified consistent across tasks: `x_fc_masking_enabled`, `x_fc_bake_instructions`, `x_fc_customer_line_ref`, `default_specification_text`, `default_bake_instructions`, `default_masking_enabled`, `material_process`, `pricelist_id`, `validity_date`, `internal_notes`, `terms_and_conditions`, `view_source`, `x_fc_material_process`, `x_fc_internal_notes`, `x_fc_print_terms`.
+
+---
+
+## Execution Handoff
+
+Plan complete and saved to `docs/superpowers/plans/2026-05-26-express-orders-plan.md`. Two execution options:
+
+**1. Subagent-Driven (recommended)** — I dispatch a fresh subagent per task, review between tasks, fast iteration.
+
+**2. Inline Execution** — Execute tasks in this session using executing-plans, batch execution with checkpoints.
+
+Which approach?