feat(configurator): part-scoped process name shows part id + revision

User feedback: the Process tab on fp.part.catalog was displaying a
bare template name ("General Processing"), making it impossible to
tell at a glance that the clone belonged to this specific part.

Root clone now inherits the template name with a part-identifier
suffix appended:
  "General Processing — 1234567 Rev 2"

Only the ROOT gets the suffix — child nodes keep their clean source
names so the tree-editor canvas doesn't get cluttered.

Suffix logic avoids doubling "Rev": if part.revision is already
prefixed with "Rev " (e.g. "Rev 2"), we don't prepend another one.

Post-upgrade hook backfills existing part-cloned roots that
pre-date this change so users see the new format without having
to re-compose (which would otherwise wipe their customisations).

fusion_plating_configurator → 19.0.13.0.0

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

fusion_plating/fusion_plating_configurator/__init__.py

@@ -33,9 +33,53 @@ def _backfill_currency(env):
         )
 
 
+def _backfill_cloned_process_names(env):
+    """Append " — <part_number> Rev <revision>" to every existing part-
+    cloned process ROOT whose name doesn't already carry the suffix.
+
+    Feedback on 2026-04-23: the Process tab on the part form was
+    showing a bare template name ("General Processing"), so users
+    couldn't tell at a glance that the clone belonged to THIS part.
+    The clone logic now adds the suffix automatically; this backfill
+    brings older clones up to the same format without forcing
+    users to re-compose (which would wipe their edits).
+
+    Idempotent: checks for a literal " — " separator before rewriting.
+    """
+    Node = env['fusion.plating.process.node']
+    roots = Node.search([
+        ('node_type', '=', 'recipe'),
+        ('part_catalog_id', '!=', False),
+        ('parent_id', '=', False),
+    ])
+    renamed = 0
+    for root in roots:
+        part = root.part_catalog_id
+        if not part:
+            continue
+        if ' — ' in (root.name or ''):
+            continue  # Already has a suffix — leave alone.
+        suffix_bits = []
+        if part.part_number:
+            suffix_bits.append(part.part_number)
+        if part.revision:
+            # `revision` sometimes already carries a "Rev " prefix
+            # (e.g. "Rev 2") — don't double up.
+            rev = part.revision.strip()
+            if not rev.lower().startswith('rev'):
+                rev = 'Rev %s' % rev
+            suffix_bits.append(rev)
+        if not suffix_bits:
+            continue
+        root.name = '%s — %s' % (root.name or '', ' '.join(suffix_bits))
+        renamed += 1
+
+
 def post_init_hook(env):
     _backfill_currency(env)
+    _backfill_cloned_process_names(env)
 
 
 def post_upgrade_hook(env):
     _backfill_currency(env)
+    _backfill_cloned_process_names(env)

fusion_plating/fusion_plating_configurator/__manifest__.py

@@ -5,7 +5,7 @@
 
 {
     'name': 'Fusion Plating — Configurator',
-    'version': '19.0.12.4.0',
+    'version': '19.0.13.0.0',
     'category': 'Manufacturing/Plating',
     'summary': 'Quotation configurator with part catalog, coating configs, and formula-based pricing engine.',
     'description': """
@@ -76,4 +76,5 @@ Provides:
     'auto_install': False,
     'post_init_hook': 'post_init_hook',
     'post_load': None,
+    'post_upgrade_hook': 'post_upgrade_hook',
 }

fusion_plating/fusion_plating_configurator/controllers/fp_part_composer_controller.py

@@ -51,8 +51,30 @@ def _clone_subtree(env, source, part, parent):
     """
     Node = env['fusion.plating.process.node']
 
+    # Root clone gets a part-identifier suffix so the part form's
+    # Default Process field reads like "General Processing — 1234567
+    # Rev 2" instead of a bare template name. Child nodes keep the
+    # source names unchanged — the suffix would only clutter the tree.
+    if parent is False:
+        suffix_bits = []
+        if part.part_number:
+            suffix_bits.append(part.part_number)
+        if part.revision:
+            # `revision` sometimes already carries a "Rev " prefix
+            # (e.g. "Rev 2") — don't double up.
+            rev = (part.revision or '').strip()
+            if rev and not rev.lower().startswith('rev'):
+                rev = 'Rev %s' % rev
+            if rev:
+                suffix_bits.append(rev)
+        node_name = source.name or ''
+        if suffix_bits:
+            node_name = '%s — %s' % (node_name, ' '.join(suffix_bits))
+    else:
+        node_name = source.name
+
     vals = {
-        'name': source.name,
+        'name': node_name,
         'code': False,  # codes must be globally unique; don't carry over
         'node_type': source.node_type,
         'sequence': source.sequence,