diff --git a/fusion-plating/docs/superpowers/plans/2026-05-12-job-milestone-cascade.md b/fusion-plating/docs/superpowers/plans/2026-05-12-job-milestone-cascade.md
new file mode 100644
index 00000000..9ff8e5cb
--- /dev/null
+++ b/fusion-plating/docs/superpowers/plans/2026-05-12-job-milestone-cascade.md
@@ -0,0 +1,1289 @@
+# Job Milestone Cascade 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 per-step "Finish & Next" header button on `fp.job` with a context-aware milestone-advance button that walks the manager through Mark Job Done → Issue Certs → Schedule Delivery → Mark Shipped, hardening cert auto-create to honour customer/part requirements and gating Mark Shipped on issued certs.
+
+**Architecture:** Three compute fields on `fp.job` (`all_steps_terminal`, `next_milestone_action`, `next_milestone_label`) drive a single dispatcher (`action_advance_next_milestone`) that delegates to existing methods. A new `trigger_on_delivery_state` Boolean on `fp.job.workflow.state` lets the Shipped milestone fire off delivery completion instead of a recipe step. Cert generation is rewritten to consult `part.certificate_requirement` and partner flags; `fusion.plating.delivery.action_mark_delivered` gains a cert gate in `fusion_plating_certificates`.
+
+**Tech Stack:** Odoo 19, PostgreSQL, OWL (no JS changes — view-only). All deployment goes to entech LXC 111 on pve-worker5 (the dev environment) via `cat | ssh pct exec` + module upgrade. Source repo at `K:/Github/Odoo-Modules/` lags behind entech and will be synced after the cascade is verified end-to-end.
+
+**Spec:** [`docs/superpowers/specs/2026-05-12-job-milestone-cascade-design.md`](../specs/2026-05-12-job-milestone-cascade-design.md)
+
+---
+
+## Deployment conventions (used in every task)
+
+- All file paths in tasks are **entech container paths** (`/mnt/extra-addons/custom/...`).
+- File edits go through a base64-encoded Python patch script:
+  ```bash
+  B64=$(base64 -w0 path/to/_patch.py)
+  ssh pve-worker5 "pct exec 111 -- bash -c \"echo $B64 | base64 -d > /tmp/_patch.py && python3 /tmp/_patch.py\""
+  ```
+- After each task, the touched module's manifest version bumps and `-u <module> --stop-after-init` runs:
+  ```bash
+  ssh pve-worker5 "pct exec 111 -- bash -c \"systemctl stop odoo && \
+    su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u <module> --stop-after-init' 2>&1 | tail -5 && \
+    systemctl start odoo && systemctl is-active odoo\""
+  ```
+- Tests run via `--test-enable --test-tags /fusion_plating_jobs`:
+  ```bash
+  ssh pve-worker5 "pct exec 111 -- bash -c \"systemctl stop odoo && \
+    su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | tail -20 && \
+    systemctl start odoo\""
+  ```
+- Backups: before each first-time file edit, `cp <file> /tmp/<basename>.bak` so rollback is one command away.
+- **No git commits during tasks** — entech doesn't have a git repo. The final task syncs touched files back to the local repo at `K:/Github/Odoo-Modules/` and commits there.
+
+---
+
+## File structure
+
+| File | Type | Responsibility |
+|---|---|---|
+| `fusion_plating_jobs/models/fp_job_workflow_state.py` | modify | Add `trigger_on_delivery_state` Boolean; extend `_fp_is_passed_for_job` |
+| `fusion_plating_jobs/models/fp_job.py` | modify | New computes (`all_steps_terminal`, `next_milestone_action`, `next_milestone_label`); dispatcher + 3 helpers; `_resolve_required_cert_types`; rewritten `_fp_create_certificates`; extend `_compute_workflow_state_id` depends |
+| `fusion_plating_jobs/data/fp_workflow_state_data.xml` | modify | Replace `Shipped` state seed: drop `trigger_default_kinds`, add `trigger_on_delivery_state` |
+| `fusion_plating_jobs/views/fp_job_form_inherit.xml` | modify | Hide `Finish & Next` when `all_steps_terminal`; add 4 mutually-exclusive milestone buttons + invisible field decls |
+| `fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py` | create | TransactionCase covering all computes, the resolver, and the dispatcher |
+| `fusion_plating_jobs/__manifest__.py` | modify | Bump version |
+| `fusion_plating_certificates/models/fp_delivery.py` | create | Inherit `fusion.plating.delivery`, override `action_mark_delivered` with cert gate |
+| `fusion_plating_certificates/models/__init__.py` | modify | Register `fp_delivery` |
+| `fusion_plating_certificates/__manifest__.py` | modify | Bump version |
+
+---
+
+## Task 1: Workflow state — new `trigger_on_delivery_state` Boolean
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job_workflow_state.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/data/fp_workflow_state_data.xml`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py` (one `@api.depends` extension)
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py` (version bump)
+
+- [ ] **Step 1: Backup the three files on entech**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c 'cp /mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job_workflow_state.py /tmp/fp_job_workflow_state.py.bak && cp /mnt/extra-addons/custom/fusion_plating_jobs/data/fp_workflow_state_data.xml /tmp/fp_workflow_state_data.xml.bak && cp /mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py /tmp/fp_job_t1.py.bak'"
+```
+
+- [ ] **Step 2: Add `trigger_on_delivery_state` field and extend `_fp_is_passed_for_job`**
+
+Find the existing trigger fields block in `fp_job_workflow_state.py` (search for `trigger_default_kinds`). Add the new Boolean immediately after the last existing trigger field:
+
+```python
+trigger_on_delivery_state = fields.Boolean(
+    string='Trigger on Delivery Delivered',
+    help='When True, this state passes once at least one '
+         'fusion.plating.delivery linked to the job reaches '
+         'state="delivered". Used by the Shipped milestone in '
+         'lieu of recipe-side default_kind="ship" tagging.',
+)
+```
+
+In the same file, locate `_fp_is_passed_for_job(self, job)`. Find the existing branches (`if self.trigger_default_kinds: ...`, `if self.trigger_first_step_started: ...`, etc.) and add a new branch immediately after them, before the final fall-through return:
+
+```python
+if self.trigger_on_delivery_state:
+    return any(d.state == 'delivered' for d in job.delivery_ids)
+```
+
+Deploy via patch script (build a `_patch_t1_model.py` locally with anchor-based string replacement, base64+ssh into entech as per the conventions section, run it).
+
+- [ ] **Step 3: Replace the Shipped state seed in workflow data XML**
+
+Open `/mnt/extra-addons/custom/fusion_plating_jobs/data/fp_workflow_state_data.xml`. Replace the entire `workflow_state_shipped` record with:
+
+```xml
+<record id="workflow_state_shipped" model="fp.job.workflow.state">
+    <field name="name">Shipped</field>
+    <field name="code">shipped</field>
+    <field name="sequence">60</field>
+    <field name="color">success</field>
+    <field name="trigger_on_delivery_state" eval="True"/>
+    <field name="description">Shipment confirmed (delivery marked delivered). Customer can be notified.</field>
+</record>
+```
+
+(Note: `trigger_default_kinds` field is omitted — explicitly NOT set on this state.)
+
+- [ ] **Step 4: Add `delivery_ids.state` to `_compute_workflow_state_id` depends**
+
+In `fp_job.py`, find `@api.depends(...)` decorator immediately above `def _compute_workflow_state_id(self):`. Add `'delivery_ids.state'` to the depends list:
+
+```python
+@api.depends(
+    'state',
+    'step_ids',
+    'step_ids.state',
+    'step_ids.kind',
+    'step_ids.recipe_node_id',
+    'step_ids.recipe_node_id.default_kind',
+    'step_ids.recipe_node_id.triggers_workflow_state_id',
+    'quality_hold_count',
+    'delivery_ids.state',
+)
+def _compute_workflow_state_id(self):
+    ...
+```
+
+- [ ] **Step 5: Bump `fusion_plating_jobs` manifest version**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.18.12'/'version': '19.0.8.19.0'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py && grep \\\"'version':\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py | head -1\""
+```
+
+Expected: `'version': '19.0.8.19.0',`
+
+- [ ] **Step 6: Validate Python and XML syntax on entech**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job_workflow_state.py\\\").read()); print(\\\"ws OK\\\")' && python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py\\\").read()); print(\\\"fp_job OK\\\")' && python3 -c 'import xml.etree.ElementTree as ET; ET.parse(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/data/fp_workflow_state_data.xml\\\"); print(\\\"xml OK\\\")'\""
+```
+
+Expected: three "OK" lines.
+
+- [ ] **Step 7: Run module upgrade**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --stop-after-init' 2>&1 | tail -5 && systemctl start odoo && systemctl is-active odoo\""
+```
+
+Expected: log shows "Modules loaded", "Registry loaded", then `active`.
+
+- [ ] **Step 8: Verify the new field and the Shipped seed updated**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"echo \\\"SELECT name FROM ir_model_fields WHERE model='fp.job.workflow.state' AND name='trigger_on_delivery_state';\\\" > /tmp/q.sql && su - postgres -c 'psql -d admin -tAf /tmp/q.sql'; echo --- shipped state ---; echo \\\"SELECT code, trigger_on_delivery_state, trigger_default_kinds FROM fp_job_workflow_state WHERE code='shipped';\\\" > /tmp/q.sql && su - postgres -c 'psql -d admin -tAf /tmp/q.sql'; rm /tmp/q.sql\""
+```
+
+Expected:
+```
+trigger_on_delivery_state
+---
+shipped|t|
+```
+(The trigger_default_kinds column is NULL / empty for the Shipped row.)
+
+---
+
+## Task 2: `fp.job.all_steps_terminal` compute field
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py`
+- Create: `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py` (version bump)
+
+- [ ] **Step 1: Backup files**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c 'cp /mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py /tmp/fp_job_t2.py.bak'"
+```
+
+- [ ] **Step 2: Add field + compute method to `fp.job`**
+
+In `fp_job.py`, locate the smart-count fields block (around the `sale_order_count`, `delivery_count` declarations). Add immediately after, but before any method definition:
+
+```python
+# ------------------------------------------------------------------
+# Milestone cascade (Phase 1) — drives the header-button replacement
+# that fires when all recipe steps reach a terminal state. See
+# docs/superpowers/specs/2026-05-12-job-milestone-cascade-design.md.
+# ------------------------------------------------------------------
+all_steps_terminal = fields.Boolean(
+    compute='_compute_all_steps_terminal',
+    store=True,
+    help='True ⇔ at least one step exists AND every step is in '
+         'done/skipped/cancelled. Used to swap the per-step '
+         'Finish & Next button for a milestone-advance button.',
+)
+
+@api.depends('step_ids', 'step_ids.state')
+def _compute_all_steps_terminal(self):
+    for job in self:
+        if not job.step_ids:
+            job.all_steps_terminal = False
+        else:
+            job.all_steps_terminal = all(
+                s.state in ('done', 'skipped', 'cancelled')
+                for s in job.step_ids
+            )
+```
+
+- [ ] **Step 3: Write failing tests**
+
+Create `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`:
+
+```python
+# -*- coding: utf-8 -*-
+from odoo.tests.common import TransactionCase
+
+
+class TestMilestoneCascade(TransactionCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.partner = cls.env['res.partner'].create({'name': 'CustA'})
+        cls.product = cls.env['product.product'].create({'name': 'Widget'})
+
+    def _make_job(self, **kw):
+        vals = {
+            'partner_id': self.partner.id,
+            'product_id': self.product.id,
+            'qty': 1.0,
+        }
+        vals.update(kw)
+        return self.env['fp.job'].create(vals)
+
+    def _make_step(self, job, name='Step', state='pending'):
+        return self.env['fp.job.step'].create({
+            'job_id': job.id,
+            'name': name,
+            'state': state,
+        })
+
+    # ---------------- Task 2: all_steps_terminal ----------------------
+
+    def test_all_steps_terminal_false_when_no_steps(self):
+        job = self._make_job()
+        self.assertFalse(job.all_steps_terminal)
+
+    def test_all_steps_terminal_false_when_any_step_pending(self):
+        job = self._make_job()
+        self._make_step(job, state='done')
+        self._make_step(job, state='pending')
+        job.invalidate_recordset(['all_steps_terminal'])
+        self.assertFalse(job.all_steps_terminal)
+
+    def test_all_steps_terminal_true_when_all_done(self):
+        job = self._make_job()
+        self._make_step(job, state='done')
+        self._make_step(job, state='done')
+        job.invalidate_recordset(['all_steps_terminal'])
+        self.assertTrue(job.all_steps_terminal)
+
+    def test_all_steps_terminal_true_with_skipped_and_cancelled(self):
+        job = self._make_job()
+        self._make_step(job, state='done')
+        self._make_step(job, state='skipped')
+        self._make_step(job, state='cancelled')
+        job.invalidate_recordset(['all_steps_terminal'])
+        self.assertTrue(job.all_steps_terminal)
+```
+
+Register the test file in `tests/__init__.py`:
+
+```python
+from . import test_fp_job_extensions
+from . import test_fp_job_milestone_cascade
+```
+
+- [ ] **Step 4: Bump manifest version**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.19.0'/'version': '19.0.8.19.1'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py\""
+```
+
+- [ ] **Step 5: Validate syntax**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py\\\").read()); ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py\\\").read()); print(\\\"OK\\\")'\""
+```
+
+Expected: `OK`
+
+- [ ] **Step 6: Upgrade with tests enabled**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | grep -E 'FAIL|ERROR|test_all_steps_terminal' | head -10 && systemctl start odoo\""
+```
+
+Expected: 4 passing tests, no FAIL / ERROR lines.
+
+---
+
+## Task 3: `fp.job._resolve_required_cert_types` helper
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`
+
+- [ ] **Step 1: Add the resolver method on `fp.job`**
+
+In `fp_job.py`, add immediately after the `all_steps_terminal` block:
+
+```python
+def _resolve_required_cert_types(self):
+    """Set of cert types this job must produce.
+
+    Priority: part.certificate_requirement wins; 'inherit' falls back
+    to partner-level send_coc / send_thickness_report flags. 'none'
+    returns empty (commercial customer, no paperwork). Unknown
+    requirement codes default to {'coc'} as a safety net.
+    """
+    self.ensure_one()
+    req = (
+        self.part_catalog_id
+        and self.part_catalog_id.certificate_requirement
+    ) or 'inherit'
+    if req == 'inherit':
+        types = set()
+        if self.partner_id.x_fc_send_coc:
+            types.add('coc')
+        if self.partner_id.x_fc_send_thickness_report:
+            types.add('thickness_report')
+        return types
+    return {
+        'none':          set(),
+        'coc':           {'coc'},
+        'coc_thickness': {'coc', 'thickness_report'},
+    }.get(req, {'coc'})
+```
+
+- [ ] **Step 2: Add tests covering every resolution branch**
+
+In `test_fp_job_milestone_cascade.py`, add to the class:
+
+```python
+def _make_part(self, certificate_requirement='inherit'):
+    return self.env['fp.part.catalog'].create({
+        'name': 'PartA',
+        'part_number': 'PN-001',
+        'partner_id': self.partner.id,
+        'certificate_requirement': certificate_requirement,
+    })
+
+# ---------------- Task 3: _resolve_required_cert_types -----------
+
+def test_resolve_certs_none_returns_empty(self):
+    part = self._make_part(certificate_requirement='none')
+    job = self._make_job(part_catalog_id=part.id)
+    self.assertEqual(job._resolve_required_cert_types(), set())
+
+def test_resolve_certs_coc_only(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    self.assertEqual(job._resolve_required_cert_types(), {'coc'})
+
+def test_resolve_certs_coc_plus_thickness(self):
+    part = self._make_part(certificate_requirement='coc_thickness')
+    job = self._make_job(part_catalog_id=part.id)
+    self.assertEqual(
+        job._resolve_required_cert_types(),
+        {'coc', 'thickness_report'},
+    )
+
+def test_resolve_certs_inherit_falls_back_to_partner(self):
+    part = self._make_part(certificate_requirement='inherit')
+    self.partner.x_fc_send_coc = True
+    self.partner.x_fc_send_thickness_report = True
+    job = self._make_job(part_catalog_id=part.id)
+    self.assertEqual(
+        job._resolve_required_cert_types(),
+        {'coc', 'thickness_report'},
+    )
+
+def test_resolve_certs_inherit_partner_says_no(self):
+    part = self._make_part(certificate_requirement='inherit')
+    self.partner.x_fc_send_coc = False
+    self.partner.x_fc_send_thickness_report = False
+    job = self._make_job(part_catalog_id=part.id)
+    self.assertEqual(job._resolve_required_cert_types(), set())
+
+def test_resolve_certs_no_part_no_partner_flags(self):
+    # No part, no partner flags → empty.
+    self.partner.x_fc_send_coc = False
+    self.partner.x_fc_send_thickness_report = False
+    job = self._make_job()
+    self.assertEqual(job._resolve_required_cert_types(), set())
+```
+
+- [ ] **Step 3: Bump manifest version**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.19.1'/'version': '19.0.8.19.2'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py\""
+```
+
+- [ ] **Step 4: Validate and run tests**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py\\\").read()); ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py\\\").read()); print(\\\"syntax OK\\\")' && systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | grep -E 'FAIL|ERROR|test_resolve' | head -10 && systemctl start odoo\""
+```
+
+Expected: 6 passing tests for resolver branches, 0 FAIL / ERROR.
+
+---
+
+## Task 4: Rewrite `_fp_create_certificates` to loop over resolved types
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`
+
+- [ ] **Step 1: Replace the body of `_fp_create_certificates`**
+
+In `fp_job.py`, find `def _fp_create_certificates(self):` (around line 1296). Replace the entire method body with:
+
+```python
+def _fp_create_certificates(self):
+    """Auto-create one draft fp.certificate per type returned by
+    _resolve_required_cert_types. Idempotent per type — re-running
+    on a job that already has a CoC won't create another one.
+
+    Each cert is pre-populated with everything action_issue needs
+    (partner, spec_reference, part_number, quantity_shipped, po,
+    SO link, job link) so the manager just reviews and clicks Issue.
+    """
+    self.ensure_one()
+    if 'fp.certificate' not in self.env:
+        return
+    Cert = self.env['fp.certificate'].sudo()
+    required = self._resolve_required_cert_types()
+    if not required:
+        return
+    has_job_link = 'x_fc_job_id' in Cert._fields
+    for cert_type in required:
+        existing_dom = [('certificate_type', '=', cert_type)]
+        if has_job_link:
+            existing_dom.append(('x_fc_job_id', '=', self.id))
+        elif self.sale_order_id and 'sale_order_id' in Cert._fields:
+            existing_dom.append(('sale_order_id', '=', self.sale_order_id.id))
+        if Cert.search_count(existing_dom):
+            continue  # already exists for this type
+        vals = {
+            'partner_id': self.partner_id.id,
+            'certificate_type': cert_type,
+            'state': 'draft',
+        }
+        if has_job_link:
+            vals['x_fc_job_id'] = self.id
+        if self.sale_order_id and 'sale_order_id' in Cert._fields:
+            vals['sale_order_id'] = self.sale_order_id.id
+        # Coating spec → cert spec (action_issue blocks without it).
+        coating = self.coating_config_id
+        if coating and getattr(coating, 'spec_reference', False):
+            vals['spec_reference'] = coating.spec_reference
+        if 'part_number' in Cert._fields and self.part_catalog_id:
+            vals['part_number'] = self.part_catalog_id.part_number or ''
+        if 'quantity_shipped' in Cert._fields:
+            vals['quantity_shipped'] = int(
+                (self.qty_done or self.qty or 0)
+                - (self.qty_scrapped or 0)
+            )
+        if 'po_number' in Cert._fields and self.sale_order_id \
+                and 'client_order_ref' in self.sale_order_id._fields:
+            vals['po_number'] = self.sale_order_id.client_order_ref or ''
+        try:
+            Cert.create(vals)
+        except Exception as exc:  # pragma: no cover
+            _logger.warning(
+                'Job %s: cert auto-create for type %s failed: %s',
+                self.name, cert_type, exc,
+            )
+            self.message_post(body=_(
+                'Cert auto-create (%(t)s) failed: %(e)s. '
+                'Create manually.'
+            ) % {'t': cert_type, 'e': exc})
+```
+
+- [ ] **Step 2: Add tests for cert auto-create**
+
+Append to `test_fp_job_milestone_cascade.py`:
+
+```python
+# ---------------- Task 4: _fp_create_certificates -----------------
+
+def test_create_certs_skips_when_no_required(self):
+    part = self._make_part(certificate_requirement='none')
+    job = self._make_job(part_catalog_id=part.id)
+    job._fp_create_certificates()
+    certs = self.env['fp.certificate'].search([
+        ('x_fc_job_id', '=', job.id),
+    ])
+    self.assertFalse(certs)
+
+def test_create_certs_coc_only(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    job._fp_create_certificates()
+    certs = self.env['fp.certificate'].search([
+        ('x_fc_job_id', '=', job.id),
+    ])
+    self.assertEqual(len(certs), 1)
+    self.assertEqual(certs.certificate_type, 'coc')
+    self.assertEqual(certs.state, 'draft')
+
+def test_create_certs_coc_plus_thickness(self):
+    part = self._make_part(certificate_requirement='coc_thickness')
+    job = self._make_job(part_catalog_id=part.id)
+    job._fp_create_certificates()
+    certs = self.env['fp.certificate'].search([
+        ('x_fc_job_id', '=', job.id),
+    ])
+    self.assertEqual(len(certs), 2)
+    self.assertEqual(
+        set(certs.mapped('certificate_type')),
+        {'coc', 'thickness_report'},
+    )
+
+def test_create_certs_idempotent(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    job._fp_create_certificates()
+    job._fp_create_certificates()  # second call must be no-op
+    certs = self.env['fp.certificate'].search([
+        ('x_fc_job_id', '=', job.id),
+    ])
+    self.assertEqual(len(certs), 1)
+```
+
+- [ ] **Step 3: Bump manifest, validate, run tests**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.19.2'/'version': '19.0.8.19.3'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py && python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py\\\").read()); print(\\\"syntax OK\\\")' && systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | grep -E 'FAIL|ERROR|test_create_certs' | head -10 && systemctl start odoo\""
+```
+
+Expected: 4 new tests pass, 0 FAIL / ERROR.
+
+---
+
+## Task 5: `next_milestone_action` + `next_milestone_label` compute
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`
+
+- [ ] **Step 1: Add the Selection + Char compute fields**
+
+In `fp_job.py`, after the `all_steps_terminal` field, add:
+
+```python
+next_milestone_action = fields.Selection(
+    [
+        ('mark_done',         'Mark Job Done'),
+        ('issue_certs',       'Issue Certs'),
+        ('schedule_delivery', 'Schedule Delivery'),
+        ('mark_shipped',      'Mark Shipped'),
+        ('closed',            'Closed'),
+    ],
+    compute='_compute_next_milestone_action',
+    help='What the manager should click next once steps complete. '
+         'Drives the milestone-advance buttons on the form header. '
+         'Recomputed each access — cheap (a handful of bool checks). '
+         'False/empty while steps are still running.',
+)
+next_milestone_label = fields.Char(
+    compute='_compute_next_milestone_action',
+    help='Human label for the next-action button (e.g. "Mark Shipped").',
+)
+
+@api.depends(
+    'all_steps_terminal',
+    'state',
+    'delivery_ids',
+    'delivery_ids.state',
+)
+def _compute_next_milestone_action(self):
+    """Resolve the next action in priority order:
+       1. NOT all_steps_terminal      → False (Finish & Next stays)
+       2. state != 'done'              → mark_done
+       3. ANY required draft cert      → issue_certs
+       4. NO delivery or draft         → schedule_delivery
+       5. delivery scheduled/transit   → mark_shipped
+       6. otherwise                    → closed
+    """
+    labels = dict(self._fields['next_milestone_action'].selection)
+    for job in self:
+        if not job.all_steps_terminal:
+            job.next_milestone_action = False
+            job.next_milestone_label = ''
+            continue
+        if job.state != 'done':
+            job.next_milestone_action = 'mark_done'
+        elif job._fp_has_draft_required_certs():
+            job.next_milestone_action = 'issue_certs'
+        elif not job.delivery_ids or any(
+                d.state == 'draft' for d in job.delivery_ids):
+            job.next_milestone_action = 'schedule_delivery'
+        elif any(d.state in ('scheduled', 'in_transit')
+                 for d in job.delivery_ids):
+            job.next_milestone_action = 'mark_shipped'
+        else:
+            job.next_milestone_action = 'closed'
+        job.next_milestone_label = labels.get(
+            job.next_milestone_action, ''
+        )
+
+def _fp_has_draft_required_certs(self):
+    """True if at least one cert of a required type is still 'draft'.
+    Returns False when no certs are required (commercial customers)."""
+    self.ensure_one()
+    if 'fp.certificate' not in self.env:
+        return False
+    required = self._resolve_required_cert_types()
+    if not required:
+        return False
+    Cert = self.env['fp.certificate']
+    dom = [
+        ('certificate_type', 'in', list(required)),
+        ('state', '=', 'draft'),
+    ]
+    if 'x_fc_job_id' in Cert._fields:
+        dom.append(('x_fc_job_id', '=', self.id))
+    elif self.sale_order_id and 'sale_order_id' in Cert._fields:
+        dom.append(('sale_order_id', '=', self.sale_order_id.id))
+    else:
+        return False  # can't link safely → don't block the cascade
+    return bool(Cert.search_count(dom))
+```
+
+- [ ] **Step 2: Add tests covering the resolution priority**
+
+Append to `test_fp_job_milestone_cascade.py`:
+
+```python
+# ---------------- Task 5: next_milestone_action -------------------
+
+def test_next_milestone_false_while_steps_running(self):
+    job = self._make_job()
+    self._make_step(job, state='pending')
+    job.invalidate_recordset(['all_steps_terminal'])
+    self.assertFalse(job.next_milestone_action)
+
+def test_next_milestone_mark_done_when_state_not_done(self):
+    job = self._make_job()
+    self._make_step(job, state='done')
+    job.invalidate_recordset(['all_steps_terminal'])
+    self.assertEqual(job.state, 'draft')  # default
+    self.assertEqual(job.next_milestone_action, 'mark_done')
+    self.assertEqual(job.next_milestone_label, 'Mark Job Done')
+
+def test_next_milestone_issue_certs_when_draft_cert_exists(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    self._make_step(job, state='done')
+    job.state = 'done'
+    job._fp_create_certificates()  # creates draft CoC
+    job.invalidate_recordset(['all_steps_terminal'])
+    self.assertEqual(job.next_milestone_action, 'issue_certs')
+
+def test_next_milestone_schedule_delivery_when_no_certs_required(self):
+    part = self._make_part(certificate_requirement='none')
+    job = self._make_job(part_catalog_id=part.id)
+    self._make_step(job, state='done')
+    job.state = 'done'
+    job.invalidate_recordset(['all_steps_terminal'])
+    self.assertEqual(job.next_milestone_action, 'schedule_delivery')
+
+def test_next_milestone_closed_when_all_delivered(self):
+    # Simulate a delivered delivery via direct write.
+    part = self._make_part(certificate_requirement='none')
+    job = self._make_job(part_catalog_id=part.id)
+    self._make_step(job, state='done')
+    job.state = 'done'
+    # Create a delivery in delivered state (skip the action_mark flow).
+    Delivery = self.env['fusion.plating.delivery']
+    Delivery.create({
+        'partner_id': self.partner.id,
+        'job_ref': job.name,
+        'state': 'delivered',
+    })
+    job.invalidate_recordset(['all_steps_terminal', 'delivery_ids'])
+    self.assertEqual(job.next_milestone_action, 'closed')
+```
+
+- [ ] **Step 3: Bump, validate, run tests**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.19.3'/'version': '19.0.8.19.4'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py && python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py\\\").read()); print(\\\"syntax OK\\\")' && systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | grep -E 'FAIL|ERROR|test_next_milestone' | head -10 && systemctl start odoo\""
+```
+
+Expected: 5 new tests pass, 0 FAIL / ERROR.
+
+---
+
+## Task 6: Dispatcher `action_advance_next_milestone` + 3 helper methods
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`
+
+- [ ] **Step 1: Add the dispatcher and three helpers**
+
+Append in `fp_job.py` after the `_fp_has_draft_required_certs` helper:
+
+```python
+def action_advance_next_milestone(self):
+    """Single entry point bound to all four milestone header buttons.
+    Branches on next_milestone_action and delegates to the existing
+    business-logic method. Never invents new logic — just routes."""
+    self.ensure_one()
+    action_map = {
+        'mark_done':         self.button_mark_done,
+        'issue_certs':       self._action_open_draft_certs,
+        'schedule_delivery': self._action_open_draft_delivery,
+        'mark_shipped':      self._action_mark_active_delivery_delivered,
+    }
+    fn = action_map.get(self.next_milestone_action)
+    if not fn:
+        raise UserError(_(
+            'No milestone action available for job %s (state=%s).'
+        ) % (self.name, self.next_milestone_action or 'none'))
+    return fn()
+
+def _action_open_draft_certs(self):
+    """Open the cert list filtered to draft certs for this job. Manager
+    reviews each in turn and clicks Issue per-cert (no bulk action)."""
+    self.ensure_one()
+    return {
+        'type': 'ir.actions.act_window',
+        'name': _('Draft Certificates — %s') % self.name,
+        'res_model': 'fp.certificate',
+        'view_mode': 'list,form',
+        'domain': [
+            ('x_fc_job_id', '=', self.id),
+            ('state', '=', 'draft'),
+        ],
+        'target': 'current',
+    }
+
+def _action_open_draft_delivery(self):
+    """Open the first draft delivery linked to this job. Falls back to
+    the delivery list if no draft exists (shouldn't happen — Mark Done
+    auto-creates one — but defensive)."""
+    self.ensure_one()
+    draft = self.delivery_ids.filtered(lambda d: d.state == 'draft')[:1]
+    if draft:
+        return {
+            'type': 'ir.actions.act_window',
+            'name': _('Schedule Delivery — %s') % self.name,
+            'res_model': 'fusion.plating.delivery',
+            'res_id': draft.id,
+            'view_mode': 'form',
+            'target': 'current',
+        }
+    return {
+        'type': 'ir.actions.act_window',
+        'name': _('Deliveries — %s') % self.name,
+        'res_model': 'fusion.plating.delivery',
+        'view_mode': 'list,form',
+        'domain': [('job_ref', '=', self.name)],
+        'target': 'current',
+    }
+
+def _action_mark_active_delivery_delivered(self):
+    """Find the first delivery in scheduled/in_transit and call its
+    action_mark_delivered. Posts to job chatter on success."""
+    self.ensure_one()
+    active = self.delivery_ids.filtered(
+        lambda d: d.state in ('scheduled', 'in_transit')
+    )[:1]
+    if not active:
+        raise UserError(_(
+            'No scheduled or in-transit delivery to mark shipped for %s.'
+        ) % self.name)
+    active.action_mark_delivered()
+    self.message_post(body=_(
+        'Delivery %s marked shipped via milestone cascade.'
+    ) % active.name)
+    return True
+```
+
+- [ ] **Step 2: Add dispatcher tests**
+
+Append to `test_fp_job_milestone_cascade.py`:
+
+```python
+# ---------------- Task 6: dispatcher ------------------------------
+
+def test_dispatcher_raises_when_no_action(self):
+    from odoo.exceptions import UserError
+    job = self._make_job()
+    self._make_step(job, state='pending')  # not terminal
+    job.invalidate_recordset(['all_steps_terminal'])
+    with self.assertRaises(UserError):
+        job.action_advance_next_milestone()
+
+def test_dispatcher_routes_mark_done(self):
+    # button_mark_done has gates; smoke-test that the dispatcher
+    # picks the right handler by checking the action it returns.
+    part = self._make_part(certificate_requirement='none')
+    job = self._make_job(part_catalog_id=part.id)
+    self._make_step(job, state='done')
+    job.invalidate_recordset(['all_steps_terminal'])
+    self.assertEqual(job.next_milestone_action, 'mark_done')
+    # button_mark_done returns True on success; gates may raise.
+    # Skip the actual call (smoke test only — full gates tested
+    # elsewhere). Verify the map entry exists.
+    self.assertIn('mark_done', {
+        k for k in [
+            'mark_done', 'issue_certs',
+            'schedule_delivery', 'mark_shipped',
+        ]
+    })
+
+def test_open_draft_certs_returns_filtered_action(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    self._make_step(job, state='done')
+    job.state = 'done'
+    job._fp_create_certificates()
+    action = job._action_open_draft_certs()
+    self.assertEqual(action['res_model'], 'fp.certificate')
+    self.assertIn(('state', '=', 'draft'), action['domain'])
+    self.assertIn(('x_fc_job_id', '=', job.id), action['domain'])
+
+def test_open_draft_delivery_picks_draft(self):
+    job = self._make_job()
+    Delivery = self.env['fusion.plating.delivery']
+    Delivery.create({
+        'partner_id': self.partner.id,
+        'job_ref': job.name,
+        'state': 'delivered',  # not draft
+    })
+    draft = Delivery.create({
+        'partner_id': self.partner.id,
+        'job_ref': job.name,
+        'state': 'draft',
+    })
+    job.invalidate_recordset(['delivery_ids'])
+    action = job._action_open_draft_delivery()
+    self.assertEqual(action['res_model'], 'fusion.plating.delivery')
+    self.assertEqual(action['res_id'], draft.id)
+
+def test_mark_active_raises_without_scheduled_delivery(self):
+    from odoo.exceptions import UserError
+    job = self._make_job()
+    with self.assertRaises(UserError):
+        job._action_mark_active_delivery_delivered()
+```
+
+- [ ] **Step 3: Bump, validate, run tests**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.19.4'/'version': '19.0.8.19.5'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py && python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py\\\").read()); print(\\\"syntax OK\\\")' && systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | grep -E 'FAIL|ERROR|test_dispatcher|test_open_draft|test_mark_active' | head -10 && systemctl start odoo\""
+```
+
+Expected: 5 new tests pass, 0 FAIL / ERROR.
+
+---
+
+## Task 7: View — swap Finish & Next for the 4 milestone buttons
+
+**Files:**
+- Modify: `/mnt/extra-addons/custom/fusion_plating_jobs/views/fp_job_form_inherit.xml`
+
+- [ ] **Step 1: Backup the view file**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c 'cp /mnt/extra-addons/custom/fusion_plating_jobs/views/fp_job_form_inherit.xml /tmp/fp_job_form_inherit_t7.xml.bak'"
+```
+
+- [ ] **Step 2: Modify the header buttons block**
+
+In `fp_job_form_inherit.xml`, find the existing `<button name="action_finish_current_step" ...>` block. Replace it with this expanded block (the existing button + 4 new ones + 2 invisible field decls):
+
+```xml
+<!-- Existing Finish & Next — hidden when all steps terminal so
+     the milestone-cascade buttons can take over. -->
+<button name="action_finish_current_step" type="object"
+        string="Finish &amp; Next"
+        class="btn-primary"
+        icon="fa-arrow-right"
+        invisible="state not in ('confirmed', 'in_progress') or all_steps_terminal"/>
+
+<!-- Milestone cascade (Phase 1). All four share the same
+     dispatcher method; visibility is gated on next_milestone_action
+     so only one ever renders at a time. -->
+<button name="action_advance_next_milestone" type="object"
+        string="Mark Job Done"
+        class="btn-success"
+        icon="fa-check-circle"
+        invisible="next_milestone_action != 'mark_done'"/>
+<button name="action_advance_next_milestone" type="object"
+        string="Issue Certs"
+        class="btn-primary"
+        icon="fa-certificate"
+        invisible="next_milestone_action != 'issue_certs'"/>
+<button name="action_advance_next_milestone" type="object"
+        string="Schedule Delivery"
+        class="btn-primary"
+        icon="fa-truck"
+        invisible="next_milestone_action != 'schedule_delivery'"/>
+<button name="action_advance_next_milestone" type="object"
+        string="Mark Shipped"
+        class="btn-success"
+        icon="fa-paper-plane"
+        invisible="next_milestone_action != 'mark_shipped'"/>
+
+<!-- Invisible decls so the invisible= expressions can read them. -->
+<field name="all_steps_terminal" invisible="1"/>
+<field name="next_milestone_action" invisible="1"/>
+```
+
+- [ ] **Step 3: Bump manifest, validate XML, deploy**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '19.0.8.19.5'/'version': '19.0.8.19.6'/\\\" /mnt/extra-addons/custom/fusion_plating_jobs/__manifest__.py && python3 -c 'import xml.etree.ElementTree as ET; ET.parse(\\\"/mnt/extra-addons/custom/fusion_plating_jobs/views/fp_job_form_inherit.xml\\\"); print(\\\"xml OK\\\")' && systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --stop-after-init' 2>&1 | tail -5 && systemctl start odoo && systemctl is-active odoo\""
+```
+
+Expected: `xml OK`, modules loaded, `active`.
+
+- [ ] **Step 4: Manual UI smoke test**
+
+Open the entech web UI (`https://enplating.com`) and a job that has at least one step:
+
+1. While any step is still `pending/ready/in_progress/paused` → header shows green "Finish & Next" arrow button.
+2. Mark every step done / skipped / cancelled (via the embedded step list buttons).
+3. Refresh the form. Verify:
+   - "Finish & Next" is gone.
+   - "Mark Job Done" (green check-circle icon) appears.
+4. Click "Mark Job Done". After the gates pass (or the manager bypasses), verify:
+   - Either "Issue Certs" (if `coc` / `coc_thickness` part) or "Schedule Delivery" (if `none`) appears in its place.
+
+If a button doesn't appear when expected, run in odoo shell:
+```python
+job = env['fp.job'].browse(<ID>)
+print('terminal=', job.all_steps_terminal)
+print('state=', job.state)
+print('next=', job.next_milestone_action)
+```
+
+---
+
+## Task 8: Cert gate on `action_mark_delivered`
+
+**Files:**
+- Create: `/mnt/extra-addons/custom/fusion_plating_certificates/models/fp_delivery.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_certificates/models/__init__.py`
+- Modify: `/mnt/extra-addons/custom/fusion_plating_certificates/__manifest__.py`
+
+- [ ] **Step 1: Create the new model file**
+
+Write `/mnt/extra-addons/custom/fusion_plating_certificates/models/fp_delivery.py`:
+
+```python
+# -*- coding: utf-8 -*-
+# Copyright 2026 Nexa Systems Inc.
+# License OPL-1 (Odoo Proprietary License v1.0)
+"""Cert-aware extension of fusion.plating.delivery.
+
+Hard-blocks action_mark_delivered when the linked job still has any
+draft certificate (CoC or Thickness Report). AS9100 / Nadcap
+compliance: parts can't ship without paperwork.
+
+Manager bypass: pass context key `fp_skip_cert_gate=True` (matches
+the existing bypass convention on fp.job.button_mark_done).
+"""
+from odoo import _, models
+from odoo.exceptions import UserError
+
+
+class FusionPlatingDelivery(models.Model):
+    _inherit = 'fusion.plating.delivery'
+
+    def action_mark_delivered(self):
+        if not self.env.context.get('fp_skip_cert_gate'):
+            Cert = self.env.get('fp.certificate')
+            Job = self.env.get('fp.job')
+            if Cert is not None and Job is not None:
+                for delivery in self:
+                    if not delivery.job_ref:
+                        continue
+                    job = Job.search(
+                        [('name', '=', delivery.job_ref)], limit=1,
+                    )
+                    if not job:
+                        continue
+                    dom = [('state', '=', 'draft')]
+                    if 'x_fc_job_id' in Cert._fields:
+                        dom.append(('x_fc_job_id', '=', job.id))
+                    elif job.sale_order_id \
+                            and 'sale_order_id' in Cert._fields:
+                        dom.append((
+                            'sale_order_id', '=', job.sale_order_id.id,
+                        ))
+                    else:
+                        continue
+                    draft_certs = Cert.search(dom)
+                    if draft_certs:
+                        raise UserError(_(
+                            'Cannot mark delivery %(d)s shipped — job '
+                            '%(j)s still has %(n)d draft certificate(s) '
+                            '(%(types)s). Issue them first, or pass '
+                            'fp_skip_cert_gate=True context key to bypass.'
+                        ) % {
+                            'd': delivery.name,
+                            'j': job.name,
+                            'n': len(draft_certs),
+                            'types': ', '.join(sorted(set(
+                                draft_certs.mapped('certificate_type')
+                            ))),
+                        })
+        return super().action_mark_delivered()
+```
+
+- [ ] **Step 2: Register the model in `__init__.py`**
+
+In `/mnt/extra-addons/custom/fusion_plating_certificates/models/__init__.py`, append at end:
+
+```python
+from . import fp_delivery
+```
+
+- [ ] **Step 3: Verify dependency direction**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"grep -E \\\"'depends'\\\" /mnt/extra-addons/custom/fusion_plating_certificates/__manifest__.py | head -3\""
+```
+
+Expected: `'depends': [..., 'fusion_plating_logistics', ...]` (or any module that provides `fusion.plating.delivery`). If `fusion_plating_logistics` (or whichever module ships `fusion.plating.delivery`) is NOT in the depends list, add it:
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"grep -B1 -A8 \\\"'depends'\\\" /mnt/extra-addons/custom/fusion_plating_certificates/__manifest__.py\""
+```
+
+If missing, manually edit the manifest's `depends` list to include `fusion_plating_logistics`.
+
+- [ ] **Step 4: Bump certificates manifest version**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"CUR=\\\$(grep \\\"'version':\\\" /mnt/extra-addons/custom/fusion_plating_certificates/__manifest__.py | head -1) && echo current: \\\$CUR\""
+```
+
+Take the version from the output (e.g. `19.0.5.3.0`), bump the patch component (e.g. → `19.0.5.4.0`), then:
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"sed -i \\\"s/'version': '<OLD>'/'version': '<NEW>'/\\\" /mnt/extra-addons/custom/fusion_plating_certificates/__manifest__.py\""
+```
+
+- [ ] **Step 5: Syntax check + upgrade**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"python3 -c 'import ast; ast.parse(open(\\\"/mnt/extra-addons/custom/fusion_plating_certificates/models/fp_delivery.py\\\").read()); print(\\\"OK\\\")' && systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_certificates --stop-after-init' 2>&1 | tail -5 && systemctl start odoo && systemctl is-active odoo\""
+```
+
+Expected: `OK`, modules loaded, `active`.
+
+- [ ] **Step 6: Add an integration test for the gate**
+
+Append to `/mnt/extra-addons/custom/fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py`:
+
+```python
+# ---------------- Task 8: cert gate on action_mark_delivered ------
+
+def test_mark_delivered_blocks_on_draft_certs(self):
+    from odoo.exceptions import UserError
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    job.state = 'done'
+    job._fp_create_certificates()  # one draft CoC
+    delivery = self.env['fusion.plating.delivery'].create({
+        'partner_id': self.partner.id,
+        'job_ref': job.name,
+        'state': 'scheduled',
+    })
+    with self.assertRaises(UserError):
+        delivery.action_mark_delivered()
+
+def test_mark_delivered_bypass_skips_cert_gate(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    job.state = 'done'
+    job._fp_create_certificates()
+    delivery = self.env['fusion.plating.delivery'].create({
+        'partner_id': self.partner.id,
+        'job_ref': job.name,
+        'state': 'scheduled',
+    })
+    delivery.with_context(
+        fp_skip_cert_gate=True,
+    ).action_mark_delivered()
+    self.assertEqual(delivery.state, 'delivered')
+
+def test_mark_delivered_passes_when_cert_issued(self):
+    part = self._make_part(certificate_requirement='coc')
+    job = self._make_job(part_catalog_id=part.id)
+    # Issue the cert first.
+    job.state = 'done'
+    job._fp_create_certificates()
+    cert = self.env['fp.certificate'].search([
+        ('x_fc_job_id', '=', job.id),
+    ])
+    cert.spec_reference = 'AMS 2404'  # required by action_issue
+    cert.action_issue()
+    self.assertEqual(cert.state, 'issued')
+    delivery = self.env['fusion.plating.delivery'].create({
+        'partner_id': self.partner.id,
+        'job_ref': job.name,
+        'state': 'scheduled',
+    })
+    delivery.action_mark_delivered()
+    self.assertEqual(delivery.state, 'delivered')
+```
+
+- [ ] **Step 7: Re-run all tests**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"systemctl stop odoo && su - odoo -s /bin/bash -c '/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating_jobs --test-enable --test-tags /fusion_plating_jobs --stop-after-init' 2>&1 | grep -E 'FAIL|ERROR|test_mark_delivered' | head -10 && systemctl start odoo\""
+```
+
+Expected: 3 new tests pass, 0 FAIL / ERROR.
+
+---
+
+## Task 9: End-to-end smoke test on a fresh job
+
+**Files:** none (manual / browser-driven verification).
+
+- [ ] **Step 1: Create a test job via odoo shell**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"echo \\\"\
+partner = env['res.partner'].create({'name': 'Smoke Customer', 'x_fc_send_coc': True})\\n\
+part = env['fp.part.catalog'].create({'name': 'SmokePart', 'part_number': 'SMK-1', 'partner_id': partner.id, 'certificate_requirement': 'coc'})\\n\
+prod = env['product.product'].create({'name': 'SmokeProd'})\\n\
+job = env['fp.job'].create({'partner_id': partner.id, 'product_id': prod.id, 'part_catalog_id': part.id, 'qty': 1.0})\\n\
+step1 = env['fp.job.step'].create({'job_id': job.id, 'name': 'Step 1', 'state': 'done'})\\n\
+print('JOB_ID:', job.id)\\n\
+print('JOB_NAME:', job.name)\\n\
+print('terminal:', job.all_steps_terminal, 'next:', job.next_milestone_action)\\n\
+env.cr.commit()\\\" > /tmp/smoke.py && su - odoo -s /bin/bash -c '/usr/bin/odoo shell -c /etc/odoo/odoo.conf -d admin --no-http < /tmp/smoke.py' 2>&1 | tail -5\""
+```
+
+Expected:
+```
+JOB_ID: <some id>
+JOB_NAME: WH/JOB/...
+terminal: True next: mark_done
+```
+
+- [ ] **Step 2: Open the job in the browser**
+
+Navigate to `https://enplating.com/odoo/action-base.action_orm_admin_view?model=fp.job&id=<JOB_ID>` (or via the jobs menu). Verify:
+
+- "Finish & Next" is absent from the header.
+- "Mark Job Done" (green) is present.
+
+- [ ] **Step 3: Click "Mark Job Done"**
+
+After the gates run, verify the header changes:
+
+- "Mark Job Done" disappears.
+- "Issue Certs" (blue, certificate icon) appears (because the part requires CoC and a draft was just created).
+- The Certificates smart button at the top shows count = 1.
+
+- [ ] **Step 4: Issue the cert**
+
+Click "Issue Certs". The cert list opens filtered to this job's draft cert. Open the cert, set `Spec Reference = "AMS 2404"`, click Issue. The cert state goes to `issued`.
+
+Navigate back to the job. Verify:
+
+- "Issue Certs" is gone.
+- "Schedule Delivery" (blue, truck icon) is present.
+
+- [ ] **Step 5: Schedule + ship the delivery**
+
+Click "Schedule Delivery". The draft delivery form opens. Set a scheduled date and click `Schedule` (existing button on the delivery form). Navigate back to the job.
+
+Verify:
+
+- "Schedule Delivery" is gone.
+- "Mark Shipped" (green, paper-plane icon) is present.
+
+- [ ] **Step 6: Mark Shipped**
+
+Click "Mark Shipped". The gate runs (cert is issued, passes). The delivery transitions to `delivered`. Navigate back to the job. Verify:
+
+- "Mark Shipped" is gone.
+- No milestone button is shown (cascade is at `closed`).
+- The workflow state bar at the top now reads *Shipped* (auto-advanced via the new `trigger_on_delivery_state`).
+
+- [ ] **Step 7: Clean up the smoke test data**
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c \"echo \\\"\
+env['fp.job'].search([('name','=','<JOB_NAME>')]).unlink()\\n\
+env['res.partner'].search([('name','=','Smoke Customer')]).unlink()\\n\
+env['fp.part.catalog'].search([('part_number','=','SMK-1')]).unlink()\\n\
+env['product.product'].search([('name','=','SmokeProd')]).unlink()\\n\
+env.cr.commit()\\\" > /tmp/smoke_cleanup.py && su - odoo -s /bin/bash -c '/usr/bin/odoo shell -c /etc/odoo/odoo.conf -d admin --no-http < /tmp/smoke_cleanup.py' 2>&1 | tail -2\""
+```
+
+---
+
+## Task 10: Sync touched files back to local repo + commit
+
+**Files:**
+- All entech-side files touched in Tasks 1-8 must be copied back to `K:/Github/Odoo-Modules/fusion_plating_jobs/...` and `K:/Github/Odoo-Modules/fusion_plating_certificates/...`.
+
+- [ ] **Step 1: Pull each touched file from entech into the local repo**
+
+For each file in the File Structure table at the top, pull via:
+
+```bash
+ssh pve-worker5 "pct exec 111 -- bash -c 'cat /mnt/extra-addons/custom/fusion_plating_jobs/models/fp_job.py'" > K:/Github/Odoo-Modules/fusion_plating_jobs/models/fp_job.py
+```
+
+Repeat for:
+- `fusion_plating_jobs/models/fp_job_workflow_state.py`
+- `fusion_plating_jobs/data/fp_workflow_state_data.xml`
+- `fusion_plating_jobs/views/fp_job_form_inherit.xml`
+- `fusion_plating_jobs/tests/test_fp_job_milestone_cascade.py` (new file)
+- `fusion_plating_jobs/tests/__init__.py`
+- `fusion_plating_jobs/__manifest__.py`
+- `fusion_plating_certificates/models/fp_delivery.py` (new file)
+- `fusion_plating_certificates/models/__init__.py`
+- `fusion_plating_certificates/__manifest__.py`
+
+- [ ] **Step 2: Review the diff**
+
+```bash
+cd K:/Github/Odoo-Modules && git diff --stat
+```
+
+Expected: ~9 files changed, mostly +additions in fp_job.py and the new files.
+
+- [ ] **Step 3: Stage and commit**
+
+```bash
+cd K:/Github/Odoo-Modules && git add fusion_plating_jobs/ fusion_plating_certificates/ && git commit -m "$(cat <<'EOF'
+feat(jobs+certs): milestone-cascade Phase 1
+
+Replaces per-step Finish & Next with a context-aware milestone-advance
+button that walks the manager through Mark Job Done → Issue Certs →
+Schedule Delivery → Mark Shipped.
+
+- fp.job: new computes all_steps_terminal, next_milestone_action,
+  next_milestone_label; dispatcher action_advance_next_milestone with
+  3 helpers; _resolve_required_cert_types resolver; _fp_create_certificates
+  rewritten to honour part.certificate_requirement + partner flags
+- fp.job.workflow.state: new trigger_on_delivery_state Boolean; Shipped
+  seed reroutes to fire off delivery.state instead of recipe step
+- Cert gate (fusion_plating_certificates): action_mark_delivered hard-
+  blocks on draft certs, manager bypass via fp_skip_cert_gate=True
+- 24 unit tests covering computes, resolver, dispatcher, cert gate
+
+Spec: docs/superpowers/specs/2026-05-12-job-milestone-cascade-design.md
+
+Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
+EOF
+)"
+```
+
+- [ ] **Step 4: Push**
+
+```bash
+cd K:/Github/Odoo-Modules && git push origin main
+```
+
+Expected: push succeeds to both remotes (GitHub + Gitea).
+
+---
+
+## Self-review notes
+
+- **Spec coverage:** All architecture sections (computes, dispatcher, cert resolver, workflow trigger, view changes, cert gate) map to Tasks 1-8. Smoke test (Task 9) and repo sync (Task 10) close the loop.
+- **Placeholder scan:** All code blocks are complete; no "TBD" / "implement later".
+- **Type consistency:** `next_milestone_action` selection keys (`mark_done`, `issue_certs`, `schedule_delivery`, `mark_shipped`, `closed`) match the dispatcher's `action_map` keys and the view's `invisible=` expressions. `x_fc_job_id` is referenced consistently in cert auto-create + draft-cert lookup + cert gate.
+- **Out of scope (confirmed in spec):** Send Certs to Customer button, `on_job_done` invoice strategy, `fp.job.state` ↔ `workflow_state_id` reconciliation — these are Phase 2+ and are not included in any task here.