# Step Library Expansion + Per-Recipe Configurability + Audit Coverage — 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:** Cover the full plating-shop workflow with new Step Kinds + audit-grade default measurements, expose per-recipe configurability for every prompt + master toggle + custom prompts + reset-to-library, surface office-to-operator instructions in the simple recipe editor with library/recipe override, wire all of it through to runtime + CoC report + tablet, and battle-test end-to-end on entech.

**Architecture:** Library `fp.step.template` is the smart default; recipe `fusion.plating.process.node` is the final say. New Selection values added to step kinds + input types. New per-row `collect` boolean (with master `collect_measurements` on the node) drives runtime filtering. Office instructions stay as `description` Html on both library and recipe; recipe override falls through to library when empty. Battle test exercises the full chain library → recipe → job → CoC report.

**Tech Stack:** Odoo 19, Python (models, computes, migrations), OWL (recipe editor), QWeb (CoC report), JSON-RPC controllers.

**Spec:** [`docs/superpowers/specs/2026-04-29-step-library-audit-design.md`](../specs/2026-04-29-step-library-audit-design.md)

**Deploy target:** entech (LXC 111 on pve-worker5, native Odoo, DB `admin`, addons at `/mnt/extra-addons/custom/`).

---

## File Map

| File | Status | Responsibility |
|---|---|---|
| `fusion_plating/models/fp_step_template.py` | MOD | Extend `default_kind`, expand `DEFAULT_INPUTS_BY_KIND`, add `action_add_common_audit_fields` |
| `fusion_plating/models/fp_step_template_input.py` | MOD | Add 4 new input types to selection |
| `fusion_plating/models/fp_process_node.py` | MOD | Add `collect_measurements` on node; add `collect` + `template_input_id` on input model; mirror new input types |
| `fusion_plating/views/fp_step_template_views.xml` | MOD | Add audit-fields button; relabel description |
| `fusion_plating/data/fp_step_template_data.xml` | NEW | Seed templates for the 8 new Step Kinds |
| `fusion_plating/migrations/19.0.18.7.0/post-migrate.py` | NEW | Backfill collect/collect_measurements; re-seed defaults |
| `fusion_plating/static/src/js/simple_recipe_editor.js` | MOD | Render Instructions + Measurements expansions; collect badge |
| `fusion_plating/static/src/xml/simple_recipe_editor.xml` | MOD | OWL templates for new affordances |
| `fusion_plating/static/src/scss/simple_recipe_editor.scss` | MOD | Styles for expansions and badges |
| `fusion_plating/controllers/simple_recipe_controller.py` | MOD | New endpoints for toggle/edit/reset |
| `fusion_plating_jobs/wizards/fp_job_step_input_wizard.py` | MOD | Filter `collect=True`; mirror new input types |
| `fusion_plating_jobs/wizards/fp_job_step_input_wizard_views.xml` | MOD | Per-input-type widgets |
| `fusion_plating_shopfloor/static/src/...` (tablet OWL) | MOD | Per-type rendering |
| `fusion_plating_reports/views/report_coc_chronological.xml` | MOD | Render branches for new types; filter `collect=True` |
| `fusion_plating/scripts/bt_step_library_audit.py` | NEW | 18-assertion battle-test |
| `fusion_plating/__manifest__.py` | MOD | Bump to `19.0.18.7.0` |
| `fusion_plating_jobs/__manifest__.py` | MOD | Bump version |
| `fusion_plating_reports/__manifest__.py` | MOD | Bump version |

---

## Phase A — Model Foundations

### Task A1: Add new input types to library template input model

**Files:**
- Modify: `fusion_plating/models/fp_step_template_input.py`

- [ ] **Step 1: Open the file and locate the `input_type` Selection at line ~27**

- [ ] **Step 2: Extend the selection with 4 new types**

Replace:

```python
    input_type = fields.Selection([
        ('text', 'Text'),
        ('number', 'Number'),
        ('boolean', 'Yes/No'),
        ('selection', 'Selection'),
        ('date', 'Date / Time'),
        ('signature', 'Signature'),
        ('time_hms', 'Time (HH:MM:SS)'),
        ('time_seconds', 'Time (seconds)'),
        ('temperature', 'Temperature'),
        ('thickness', 'Thickness'),
        ('pass_fail', 'Pass / Fail'),
    ], string='Input Type', required=True, default='text')
```

With:

```python
    input_type = fields.Selection([
        ('text', 'Text'),
        ('number', 'Number'),
        ('boolean', 'Yes/No'),
        ('selection', 'Selection'),
        ('date', 'Date / Time'),
        ('signature', 'Signature'),
        ('time_hms', 'Time (HH:MM:SS)'),
        ('time_seconds', 'Time (seconds)'),
        ('temperature', 'Temperature'),
        ('thickness', 'Thickness'),
        ('pass_fail', 'Pass / Fail'),
        ('photo', 'Photo'),
        ('multi_point_thickness', 'Multi-Point Thickness (avg)'),
        ('bath_chemistry_panel', 'Bath Chemistry Panel'),
        ('ph', 'pH'),
    ], string='Input Type', required=True, default='text')
```

- [ ] **Step 3: Verify Python parses cleanly**

Run: `python -c "import ast; ast.parse(open('K:/Github/Odoo-Modules/fusion_plating/fusion_plating/models/fp_step_template_input.py').read())"`
Expected: silent (no error).

### Task A2: Mirror new input types on the recipe-step (process node) input model

**Files:**
- Modify: `fusion_plating/models/fp_process_node.py:621-640` (the `input_type` Selection on the inline input model)

- [ ] **Step 1: Locate the input_type Selection block (search for `('thickness', 'Thickness')`)**

- [ ] **Step 2: Add the four new entries above the closing bracket**

Replace:

```python
    input_type = fields.Selection(
        [
            ('text', 'Text'),
            ('number', 'Number'),
            ('boolean', 'Yes/No'),
            ('selection', 'Selection'),
            ('time_hms', 'Time (HH:MM:SS)'),
            ('time_seconds', 'Time (seconds)'),
            ('temperature', 'Temperature'),
            ('thickness', 'Thickness'),
            ('pass_fail', 'Pass / Fail'),
            ('date', 'Date / Time'),
            ('signature', 'Signature'),
            ('location_picker', 'Location Picker'),
            ('customer_wo', 'Customer WO #'),
        ],
        string='Input Type',
        required=True,
        default='text',
    )
```

With:

```python
    input_type = fields.Selection(
        [
            ('text', 'Text'),
            ('number', 'Number'),
            ('boolean', 'Yes/No'),
            ('selection', 'Selection'),
            ('time_hms', 'Time (HH:MM:SS)'),
            ('time_seconds', 'Time (seconds)'),
            ('temperature', 'Temperature'),
            ('thickness', 'Thickness'),
            ('pass_fail', 'Pass / Fail'),
            ('date', 'Date / Time'),
            ('signature', 'Signature'),
            ('location_picker', 'Location Picker'),
            ('customer_wo', 'Customer WO #'),
            ('photo', 'Photo'),
            ('multi_point_thickness', 'Multi-Point Thickness (avg)'),
            ('bath_chemistry_panel', 'Bath Chemistry Panel'),
            ('ph', 'pH'),
        ],
        string='Input Type',
        required=True,
        default='text',
    )
```

### Task A3: Add `collect`, `template_input_id`, `collect_measurements` fields

**Files:**
- Modify: `fusion_plating/models/fp_process_node.py`

- [ ] **Step 1: Locate the inline input model class (it's a nested model inside fp_process_node.py — search for `_name = 'fusion.plating.process.node.input'`).**

- [ ] **Step 2: Add `collect` and `template_input_id` after the `compliance_tag` field (around line 698)**

Insert immediately before the class' closing `_sql_constraints` or the next field block:

```python
    # ===== Sub 12d — per-recipe configurability =============================
    collect = fields.Boolean(
        string='Collect This Measurement',
        default=True,
        help='Toggle off to skip this prompt at runtime without deleting it. '
             'Recipe authors use this to opt out of library-seeded prompts '
             'without affecting the library itself.',
    )
    template_input_id = fields.Many2one(
        'fp.step.template.input',
        string='Source Library Prompt',
        ondelete='set null',
        help='Set when this row was snapshot-copied from a library template '
             'prompt. Powers "Reset to Library Defaults" — rows where this '
             'is False are treated as recipe-only custom prompts and '
             'survive the reset.',
    )
```

- [ ] **Step 3: Add `collect_measurements` boolean on the parent node model**

Locate the main `fusion.plating.process.node` model class (search for `_name = 'fusion.plating.process.node'` — the node itself, not the input child). Find a sensible location near the existing `description` field (search for `description = fields.Html`) and add immediately after:

```python
    collect_measurements = fields.Boolean(
        string='Collect Measurements at Runtime',
        default=True,
        help='Master switch. When off, the operator wizard skips this step '
             'entirely (no input prompts shown). Use for housekeeping steps '
             'or when no measurement is needed for this recipe.',
    )
```

- [ ] **Step 4: Verify Python parses**

Run: `python -c "import ast; ast.parse(open('K:/Github/Odoo-Modules/fusion_plating/fusion_plating/models/fp_process_node.py').read())"`
Expected: silent.

- [ ] **Step 5: Commit Phase A**

```bash
cd K:/Github/Odoo-Modules/fusion_plating
git add fusion_plating/models/fp_step_template_input.py fusion_plating/models/fp_process_node.py
git commit -m "model(step-library): add 4 new input types + per-recipe collect toggles"
```

---

## Phase B — Library DEFAULT_INPUTS_BY_KIND + 8 New Step Kinds

### Task B1: Add 8 new Step Kinds to default_kind Selection

**Files:**
- Modify: `fusion_plating/models/fp_step_template.py:77-94`

- [ ] **Step 1: Locate the `default_kind` Selection field (around line 77)**

- [ ] **Step 2: Replace it with the expanded list**

Replace:

```python
    default_kind = fields.Selection([
        ('cleaning', 'Cleaning'),
        ('etch', 'Etch'),
        ('rinse', 'Rinse'),
        ('plate', 'Plating'),
        ('bake', 'Bake'),
        ('inspect', 'Inspection'),
        ('racking', 'Racking'),
        ('derack', 'De-Racking'),
        ('mask', 'Masking'),
        ('demask', 'De-Masking'),
        ('dry', 'Drying'),
        ('wbf_test', 'Water Break Free Test'),
        ('final_inspect', 'Final Inspection'),
        ('ship', 'Shipping'),
        ('gating', 'Gating'),
        ('contract_review', 'Contract Review (QA-005)'),
    ], string='Step Kind', help='Drives sane-default input seeding.')
```

With:

```python
    default_kind = fields.Selection([
        ('receiving', 'Receiving / Incoming Inspection'),
        ('contract_review', 'Contract Review (QA-005)'),
        ('racking', 'Racking'),
        ('mask', 'Masking'),
        ('cleaning', 'Cleaning'),
        ('electroclean', 'Electroclean'),
        ('etch', 'Etch / Activation'),
        ('rinse', 'Rinse'),
        ('strike', 'Strike (Wood\'s Nickel / Activation)'),
        ('plate', 'Plating'),
        ('replenishment', 'Tank Replenishment'),
        ('wbf_test', 'Water Break Free Test'),
        ('dry', 'Drying'),
        ('bake', 'Bake (HE Relief / Stress Relief)'),
        ('demask', 'De-Masking'),
        ('derack', 'De-Racking'),
        ('inspect', 'Inspection'),
        ('hardness_test', 'Hardness Test (HV / HK / HRC)'),
        ('adhesion_test', 'Adhesion Test'),
        ('salt_spray', 'Salt Spray / Corrosion Test'),
        ('final_inspect', 'Final Inspection'),
        ('packaging', 'Packaging / Pre-Ship'),
        ('ship', 'Shipping'),
        ('gating', 'Gating'),
    ], string='Step Kind', help='Drives sane-default input seeding.')
```

The list is now ordered roughly by typical workflow phase to make it easier for shop authors to scan.

### Task B2: Expand DEFAULT_INPUTS_BY_KIND for all kinds

**Files:**
- Modify: `fusion_plating/models/fp_step_template.py:140-213`

- [ ] **Step 1: Replace the `DEFAULT_INPUTS_BY_KIND` dict with the full expanded version**

Replace the entire dict (lines 140 through the closing `}` around line 213) with:

```python
    DEFAULT_INPUTS_BY_KIND = {
        'receiving': [
            {'name': 'Qty Received', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 10, 'required': True},
            {'name': 'Qty Rejected', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 20},
            {'name': 'Customer PO# Verified', 'input_type': 'boolean', 'sequence': 30},
            {'name': 'Packing Slip #', 'input_type': 'text', 'sequence': 40},
            {'name': 'Condition Notes', 'input_type': 'text', 'sequence': 50},
            {'name': 'Damage Photo', 'input_type': 'photo', 'sequence': 60},
            {'name': 'Inspector Initials', 'input_type': 'signature',
             'sequence': 70, 'required': True},
        ],
        'cleaning': [
            {'name': 'Actual Time', 'input_type': 'time_seconds',
             'target_unit': 's', 'sequence': 10},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 20},
            {'name': 'Bath ID', 'input_type': 'text', 'sequence': 30},
            {'name': 'Ultrasonic On', 'input_type': 'boolean', 'sequence': 40},
            {'name': 'Titration Done', 'input_type': 'boolean', 'sequence': 50},
        ],
        'electroclean': [
            {'name': 'Actual Time', 'input_type': 'time_seconds',
             'target_unit': 's', 'sequence': 10},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 20},
            {'name': 'Amperage', 'input_type': 'number', 'sequence': 30,
             'hint': 'A'},
            {'name': 'Voltage', 'input_type': 'number', 'sequence': 40,
             'hint': 'V'},
            {'name': 'Current Density', 'input_type': 'number', 'sequence': 50,
             'hint': 'ASF (A per sq ft)'},
            {'name': 'Polarity', 'input_type': 'selection', 'sequence': 60,
             'selection_options': 'anodic,cathodic,periodic'},
            {'name': 'Bath ID', 'input_type': 'text', 'sequence': 70},
        ],
        'etch': [
            {'name': 'Actual Time', 'input_type': 'time_seconds',
             'target_unit': 's', 'sequence': 10},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 20},
            {'name': 'Acid Concentration', 'input_type': 'number', 'sequence': 30,
             'hint': '% or g/L'},
            {'name': 'Bath ID', 'input_type': 'text', 'sequence': 40},
            {'name': 'HE Risk Flag', 'input_type': 'boolean', 'sequence': 50,
             'hint': 'Hydrogen Embrittlement risk for high-strength steel'},
        ],
        'rinse': [
            {'name': 'Rinse Type', 'input_type': 'selection', 'sequence': 10,
             'selection_options': 'cascade,spray,DI,city'},
            {'name': 'Conductivity', 'input_type': 'number', 'sequence': 20,
             'hint': 'µS/cm — required for DI rinses'},
            {'name': 'Actual Time', 'input_type': 'time_seconds',
             'target_unit': 's', 'sequence': 30},
        ],
        'strike': [
            {'name': 'Actual Time', 'input_type': 'time_seconds',
             'target_unit': 's', 'sequence': 10},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 20},
            {'name': 'Amperage', 'input_type': 'number', 'sequence': 30,
             'hint': 'A'},
            {'name': 'Voltage', 'input_type': 'number', 'sequence': 40,
             'hint': 'V'},
            {'name': 'Current Density', 'input_type': 'number', 'sequence': 50,
             'hint': 'ASF'},
            {'name': 'Bath ID', 'input_type': 'text', 'sequence': 60},
        ],
        'plate': [
            {'name': 'Actual Time', 'input_type': 'time_hms',
             'target_unit': 'min', 'sequence': 10},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 20},
            {'name': 'Bath ID', 'input_type': 'text', 'sequence': 30},
            {'name': 'pH', 'input_type': 'ph', 'sequence': 40},
            {'name': 'Bath Concentration', 'input_type': 'number', 'sequence': 50,
             'hint': 'g/L'},
            {'name': 'Current Density', 'input_type': 'number', 'sequence': 60,
             'hint': 'ASF — electroplate only'},
            {'name': 'Plating Thickness', 'input_type': 'multi_point_thickness',
             'target_unit': 'in', 'sequence': 70},
        ],
        'replenishment': [
            {'name': 'Bath ID', 'input_type': 'text', 'sequence': 10,
             'required': True},
            {'name': 'Chemistry Added', 'input_type': 'text', 'sequence': 20,
             'hint': 'name + amount, e.g. "Nickel sulfamate 500mL"'},
            {'name': 'pH Before', 'input_type': 'ph', 'sequence': 30},
            {'name': 'pH After', 'input_type': 'ph', 'sequence': 40},
            {'name': 'Concentration Before', 'input_type': 'number', 'sequence': 50},
            {'name': 'Concentration After', 'input_type': 'number', 'sequence': 60},
            {'name': 'Operator Initials', 'input_type': 'signature',
             'sequence': 70, 'required': True},
        ],
        'wbf_test': [
            {'name': 'Result', 'input_type': 'pass_fail', 'sequence': 10,
             'required': True},
            {'name': 'Retest Count', 'input_type': 'number', 'sequence': 20},
            {'name': 'Photo on FAIL', 'input_type': 'photo', 'sequence': 30},
        ],
        'dry': [
            {'name': 'Dry Method', 'input_type': 'selection', 'sequence': 10,
             'selection_options': 'hot air,oven,spin'},
            {'name': 'Actual Time', 'input_type': 'time_seconds',
             'target_unit': 's', 'sequence': 20},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 30},
        ],
        'bake': [
            {'name': 'Time In', 'input_type': 'date', 'sequence': 10},
            {'name': 'Time Out', 'input_type': 'date', 'sequence': 20},
            {'name': 'Actual Temperature', 'input_type': 'temperature',
             'target_unit': 'f', 'sequence': 30},
            {'name': 'Oven ID', 'input_type': 'text', 'sequence': 40},
            {'name': 'Chart Recorder File', 'input_type': 'photo', 'sequence': 50,
             'hint': 'Attach AMS-2759 chart-recorder file'},
        ],
        'racking': [
            {'name': 'Actual Qty', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 10, 'required': True},
            {'name': 'Rack ID', 'input_type': 'text', 'sequence': 20},
            {'name': 'Masking Applied', 'input_type': 'boolean', 'sequence': 30},
            {'name': 'Photo of Racked Load', 'input_type': 'photo', 'sequence': 40},
        ],
        'derack': [
            {'name': 'Actual Qty', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 10},
            {'name': 'Mask Removal Method', 'input_type': 'selection', 'sequence': 20,
             'selection_options': 'mechanical,solvent,thermal,not applicable'},
            {'name': 'Residue Check', 'input_type': 'pass_fail', 'sequence': 30},
        ],
        'mask': [
            {'name': 'Actual Qty', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 10},
            {'name': 'Mask Material', 'input_type': 'selection', 'sequence': 20,
             'selection_options': 'Microshield,latex tape,vinyl plugs,wax,other'},
            {'name': 'Photo of Masked Parts', 'input_type': 'photo', 'sequence': 30},
        ],
        'demask': [
            {'name': 'Residue Check', 'input_type': 'pass_fail', 'sequence': 10},
            {'name': 'Surface Condition', 'input_type': 'selection', 'sequence': 20,
             'selection_options': 'clean,marks,needs rework'},
        ],
        'inspect': [
            {'name': 'Result', 'input_type': 'pass_fail', 'sequence': 10,
             'required': True},
            {'name': 'Defect Type', 'input_type': 'selection', 'sequence': 20,
             'selection_options': 'pitting,burn,blister,peel,missing coverage,none'},
            {'name': 'Thickness Sample', 'input_type': 'thickness',
             'target_unit': 'in', 'sequence': 30},
            {'name': 'Photo', 'input_type': 'photo', 'sequence': 40},
            {'name': 'Inspector Signature', 'input_type': 'signature', 'sequence': 50},
        ],
        'hardness_test': [
            {'name': 'Test Load', 'input_type': 'number', 'sequence': 10,
             'hint': 'gf'},
            {'name': 'Readings (HV/HK/HRC)', 'input_type': 'multi_point_thickness',
             'sequence': 20, 'hint': 'Three indents minimum'},
            {'name': 'Equipment ID', 'input_type': 'text', 'sequence': 30},
            {'name': 'Last Calibration Date', 'input_type': 'date', 'sequence': 40},
        ],
        'adhesion_test': [
            {'name': 'Test Method', 'input_type': 'selection', 'sequence': 10,
             'selection_options': 'bend,tape,burnish,file'},
            {'name': 'Result', 'input_type': 'pass_fail', 'sequence': 20,
             'required': True},
            {'name': 'Photo of Coupon', 'input_type': 'photo', 'sequence': 30},
        ],
        'salt_spray': [
            {'name': 'Test Duration', 'input_type': 'number', 'sequence': 10,
             'hint': 'hours'},
            {'name': 'Result', 'input_type': 'pass_fail', 'sequence': 20,
             'required': True},
            {'name': 'Red Rust %', 'input_type': 'number', 'sequence': 30},
            {'name': 'White Corrosion %', 'input_type': 'number', 'sequence': 40},
            {'name': 'Lab Report', 'input_type': 'photo', 'sequence': 50,
             'hint': 'Attach scanned lab report'},
        ],
        'final_inspect': [
            {'name': 'Outgoing Part Count Verified',
             'input_type': 'boolean', 'sequence': 10},
            {'name': 'Qty Accepted', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 20},
            {'name': 'Qty Rejected', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 30},
            {'name': 'Defect Categorization', 'input_type': 'selection', 'sequence': 35,
             'selection_options': 'pitting,burn,blister,peel,missing coverage,dimensional,none'},
            {'name': 'Actual Coating Thickness',
             'input_type': 'multi_point_thickness',
             'target_unit': 'in', 'sequence': 40},
            {'name': 'Dimensional Verification', 'input_type': 'pass_fail',
             'sequence': 45},
            {'name': 'Surface Finish (Ra)', 'input_type': 'number', 'sequence': 47,
             'hint': 'µin'},
            {'name': 'Pass/Fail', 'input_type': 'pass_fail', 'sequence': 50,
             'required': True},
            {'name': 'Inspector Signature', 'input_type': 'signature', 'sequence': 60},
        ],
        'packaging': [
            {'name': 'Packaging Type', 'input_type': 'selection', 'sequence': 10,
             'selection_options': 'VCI bag,bubble wrap,separator paper,custom crate,other'},
            {'name': 'Qty Per Package', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 20},
            {'name': 'Package Count', 'input_type': 'number', 'sequence': 30},
            {'name': 'Cert Package Included', 'input_type': 'boolean', 'sequence': 40},
            {'name': 'Customer-Supplied Packaging', 'input_type': 'boolean',
             'sequence': 50},
        ],
        'ship': [
            {'name': 'Outgoing Qty', 'input_type': 'number',
             'target_unit': 'each', 'sequence': 10, 'required': True},
            {'name': 'Carrier', 'input_type': 'selection', 'sequence': 20,
             'selection_options': 'UPS,FedEx,Purolator,Customer Pickup,Other'},
            {'name': 'Tracking #', 'input_type': 'text', 'sequence': 30},
            {'name': 'BoL #', 'input_type': 'text', 'sequence': 40},
            {'name': 'Photo of Sealed Shipment', 'input_type': 'photo',
             'sequence': 50},
        ],
        'gating': [],
        'contract_review': [
            {'name': 'Reviewer Initials', 'input_type': 'signature', 'sequence': 10},
            {'name': 'Date Reviewed', 'input_type': 'date', 'sequence': 20},
            {'name': 'QA-005 Approved', 'input_type': 'pass_fail', 'sequence': 30},
        ],
    }
```

### Task B3: Add `action_add_common_audit_fields` method

**Files:**
- Modify: `fusion_plating/models/fp_step_template.py` (after `action_seed_default_inputs`, around line 234)

- [ ] **Step 1: Append after `action_seed_default_inputs`**

```python
    COMMON_AUDIT_FIELDS = [
        {'name': 'Operator Initials', 'input_type': 'signature',
         'required': True, 'sequence': 800},
        {'name': 'Bath ID', 'input_type': 'text', 'sequence': 810},
        {'name': 'Photo on Failure', 'input_type': 'photo', 'sequence': 820,
         'hint': 'upload only if failure observed'},
        {'name': 'Equipment ID', 'input_type': 'text', 'sequence': 830},
    ]

    def action_add_common_audit_fields(self):
        """Idempotently append the common audit fields to this template.
        Skips rows whose name already exists. Logs to chatter.
        """
        Input = self.env['fp.step.template.input']
        for tpl in self:
            existing_names = set(tpl.input_template_ids.mapped('name'))
            added = []
            for spec in self.COMMON_AUDIT_FIELDS:
                if spec['name'] in existing_names:
                    continue
                Input.create({
                    'template_id': tpl.id,
                    **spec,
                })
                added.append(spec['name'])
            if added:
                tpl.message_post(
                    body=_('Added common audit fields: %s') % ', '.join(added),
                    message_type='notification',
                    subtype_xmlid='mail.mt_note',
                )
        return True
```

- [ ] **Step 2: Verify Python parses**

Run: `python -c "import ast; ast.parse(open('K:/Github/Odoo-Modules/fusion_plating/fusion_plating/models/fp_step_template.py').read())"`
Expected: silent.

- [ ] **Step 3: Commit Phase B model changes**

```bash
git add fusion_plating/models/fp_step_template.py
git commit -m "model(step-library): add 8 new Step Kinds + expanded defaults + audit-fields one-click"
```

---

## Phase C — Library Views

### Task C1: Surface "Add Common Audit Fields" button + relabel description

**Files:**
- Modify: `fusion_plating/views/fp_step_template_views.xml`

- [ ] **Step 1: In the form view's `<header>` (around line 32), add a second button after `action_seed_default_inputs`**

Replace:

```xml
                <header>
                    <button name="action_seed_default_inputs" type="object"
                            string="Seed Default Inputs" class="btn-secondary"
                            invisible="not default_kind"/>
                </header>
```

With:

```xml
                <header>
                    <button name="action_seed_default_inputs" type="object"
                            string="Seed Default Inputs" class="btn-secondary"
                            invisible="not default_kind"/>
                    <button name="action_add_common_audit_fields" type="object"
                            string="+ Common Audit Fields"
                            class="btn-secondary"
                            help="Append Operator Initials, Bath ID, Photo on Failure, Equipment ID"/>
                </header>
```

- [ ] **Step 2: Update the Instructions tab label and the field placeholder**

Replace:

```xml
                        <page string="Instructions" name="instructions">
                            <field name="description"
                                   placeholder="Rich-text instructions / WI reference."/>
                        </page>
```

With:

```xml
                        <page string="Default Operator Instructions" name="instructions">
                            <div class="alert alert-info" role="alert">
                                Standing instructions the office gives operators for this
                                step. Snapshot-copied onto every recipe that uses this
                                step. Recipe authors can override per recipe.
                            </div>
                            <field name="description"
                                   placeholder="e.g. Mask threaded holes with vinyl plugs. Use Microshield for through-holes."/>
                        </page>
```

- [ ] **Step 3: Commit**

```bash
git add fusion_plating/views/fp_step_template_views.xml
git commit -m "view(step-library): audit-fields button + relabel as Default Operator Instructions"
```

---

## Phase D — Migration Script

### Task D1: Create migration directory and post-migrate script

**Files:**
- Create: `fusion_plating/migrations/19.0.18.7.0/post-migrate.py`

- [ ] **Step 1: Verify migration directory exists**

Run: `ls K:/Github/Odoo-Modules/fusion_plating/fusion_plating/migrations/`
If `19.0.18.7.0/` doesn't exist, create it: `mkdir -p K:/Github/Odoo-Modules/fusion_plating/fusion_plating/migrations/19.0.18.7.0/`

- [ ] **Step 2: Write the migration script**

Content:

```python
# -*- coding: utf-8 -*-
# Copyright 2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
"""Post-migration for 19.0.18.7.0 — Step Library audit expansion.

1. Default `collect=True` on all existing recipe-step inputs.
2. Default `collect_measurements=True` on all existing recipe steps.
3. Re-run action_seed_default_inputs on every existing template to
   pull in the newly-added prompts (idempotent — skips rows whose
   name is already present, so user edits survive).
4. Backfill template_input_id by name-matching against the linked
   library template (best-effort).
"""

import logging

_logger = logging.getLogger(__name__)


def migrate(cr, version):
    if not version:
        return
    from odoo.api import Environment, SUPERUSER_ID
    env = Environment(cr, SUPERUSER_ID, {})

    # 1. Default collect=True on all recipe-step inputs that have NULL collect
    cr.execute("""
        UPDATE fusion_plating_process_node_input
        SET collect = TRUE
        WHERE collect IS NULL
    """)
    _logger.info("Backfilled collect=True on %s recipe-step inputs", cr.rowcount)

    # 2. Default collect_measurements=True on recipe steps with NULL
    cr.execute("""
        UPDATE fusion_plating_process_node
        SET collect_measurements = TRUE
        WHERE collect_measurements IS NULL
    """)
    _logger.info("Backfilled collect_measurements=True on %s recipe steps", cr.rowcount)

    # 3. Re-seed defaults on every existing template (idempotent)
    Template = env['fp.step.template']
    templates = Template.search([('default_kind', '!=', False)])
    for tpl in templates:
        try:
            tpl.action_seed_default_inputs()
        except Exception as e:
            _logger.warning(
                "Failed to re-seed defaults on template %s: %s", tpl.id, e
            )
    _logger.info("Re-seeded defaults on %s templates", len(templates))

    # 4. Backfill template_input_id — name-match recipe-node inputs against
    #    their parent recipe's first-level library-template snapshot. Best
    #    effort: nodes without a clear library link stay with template_input_id=False.
    cr.execute("""
        SELECT ni.id, ni.name, ni.node_id
        FROM fusion_plating_process_node_input ni
        WHERE ni.template_input_id IS NULL
    """)
    rows = cr.fetchall()
    matched = 0
    for ni_id, name, node_id in rows:
        # Find the library template via the recipe node's process_type or by
        # tank match — best-effort, no guarantees. If the node has a
        # template_id field, use that directly.
        cr.execute("""
            SELECT template_id FROM fusion_plating_process_node WHERE id = %s
        """, (node_id,))
        row = cr.fetchone()
        if not row or not row[0]:
            continue
        tpl_id = row[0]
        # Find the matching input by name in the library template
        cr.execute("""
            SELECT id FROM fp_step_template_input
            WHERE template_id = %s AND name = %s LIMIT 1
        """, (tpl_id, name))
        match = cr.fetchone()
        if match:
            cr.execute("""
                UPDATE fusion_plating_process_node_input
                SET template_input_id = %s WHERE id = %s
            """, (match[0], ni_id))
            matched += 1
    _logger.info("Backfilled template_input_id on %s recipe-step inputs", matched)
```

NOTE: the SQL queries use the actual Odoo table names. The recipe-step model is `fusion.plating.process.node` → table `fusion_plating_process_node`. The inline input model is `fusion.plating.process.node.input` → table `fusion_plating_process_node_input`. **Verify these table names** before running the migration by running:

```bash
ssh pve-worker5 "pct exec 111 -- bash -c 'su - postgres -s /bin/bash -c \"psql -d admin -c \\\"\\\\dt | grep -i process_node\\\"\"'"
```

If the actual table names differ, update the SQL accordingly.

- [ ] **Step 3: Verify migration directory has __init__ if needed**

Odoo migrations don't strictly need an `__init__.py` in the version directory — they're picked up by file naming. Skip unless your repo convention says otherwise.

- [ ] **Step 4: Commit**

```bash
git add fusion_plating/migrations/19.0.18.7.0/post-migrate.py
git commit -m "migration(step-library): backfill collect/collect_measurements + re-seed defaults"
```

---

## Phase E — Runtime Wizard Filtering

### Task E1: Filter input wizard to `collect=True` only + skip when master is off

**Files:**
- Modify: `fusion_plating_jobs/wizards/fp_job_step_input_wizard.py:64-92`

- [ ] **Step 1: Locate the `default_get` method (around line 64)**

- [ ] **Step 2: Update the filter logic**

Replace:

```python
    @api.model
    def default_get(self, fields_list):
        defaults = super().default_get(fields_list)
        ctx = self.env.context
        step_id = ctx.get('default_step_id') or ctx.get('active_id')
        if not step_id:
            return defaults
        step = self.env['fp.job.step'].browse(step_id)
        if not step.exists() or not step.recipe_node_id:
            return defaults
        defaults['step_id'] = step.id
        node = step.recipe_node_id
        # Filter to step_input prompts only — transition inputs go on the
        # Move wizard, not here.
        inputs = node.input_ids
        if 'kind' in inputs._fields:
            inputs = inputs.filtered(lambda i: i.kind == 'step_input')
        defaults['line_ids'] = [(0, 0, {
            'node_input_id': inp.id,
            'name': inp.name,
            'input_type': inp.input_type,
            'target_min': getattr(inp, 'target_min', 0.0) or 0.0,
            'target_max': getattr(inp, 'target_max', 0.0) or 0.0,
            'target_unit': getattr(inp, 'target_unit', False) or False,
        }) for inp in inputs]
        return defaults
```

With:

```python
    @api.model
    def default_get(self, fields_list):
        defaults = super().default_get(fields_list)
        ctx = self.env.context
        step_id = ctx.get('default_step_id') or ctx.get('active_id')
        if not step_id:
            return defaults
        step = self.env['fp.job.step'].browse(step_id)
        if not step.exists() or not step.recipe_node_id:
            return defaults
        defaults['step_id'] = step.id
        node = step.recipe_node_id
        # Master switch — when off, skip the wizard entirely.
        if hasattr(node, 'collect_measurements') and not node.collect_measurements:
            return defaults
        # Filter to step_input prompts only — transition inputs go on the
        # Move wizard, not here. Also filter to collect=True (per-recipe
        # opt-out, default True).
        inputs = node.input_ids
        if 'kind' in inputs._fields:
            inputs = inputs.filtered(lambda i: i.kind == 'step_input')
        if 'collect' in inputs._fields:
            inputs = inputs.filtered(lambda i: i.collect)
        defaults['line_ids'] = [(0, 0, {
            'node_input_id': inp.id,
            'name': inp.name,
            'input_type': inp.input_type,
            'target_min': getattr(inp, 'target_min', 0.0) or 0.0,
            'target_max': getattr(inp, 'target_max', 0.0) or 0.0,
            'target_unit': getattr(inp, 'target_unit', False) or False,
        }) for inp in inputs]
        return defaults
```

### Task E2: Mirror new input types on wizard line model

**Files:**
- Modify: `fusion_plating_jobs/wizards/fp_job_step_input_wizard.py` (top of file, around line 30)

- [ ] **Step 1: Update `_FP_INPUT_TYPE_SELECTION` to include the 4 new types**

Replace:

```python
_FP_INPUT_TYPE_SELECTION = [
    ('text',          'Text'),
    ('number',        'Number'),
    ('boolean',       'Yes/No'),
    ('selection',     'Selection'),
    ('date',          'Date / Time'),
    ('signature',     'Signature'),
    ('time_hms',      'Time (HH:MM:SS)'),
    ('time_seconds',  'Time (seconds)'),
    ('temperature',   'Temperature'),
    ('thickness',     'Thickness'),
    ('pass_fail',     'Pass / Fail'),
]
```

With:

```python
_FP_INPUT_TYPE_SELECTION = [
    ('text',                   'Text'),
    ('number',                 'Number'),
    ('boolean',                'Yes/No'),
    ('selection',              'Selection'),
    ('date',                   'Date / Time'),
    ('signature',              'Signature'),
    ('time_hms',               'Time (HH:MM:SS)'),
    ('time_seconds',           'Time (seconds)'),
    ('temperature',            'Temperature'),
    ('thickness',              'Thickness'),
    ('pass_fail',              'Pass / Fail'),
    ('photo',                  'Photo'),
    ('multi_point_thickness',  'Multi-Point Thickness (avg)'),
    ('bath_chemistry_panel',   'Bath Chemistry Panel'),
    ('ph',                     'pH'),
]
```

- [ ] **Step 2: Find the wizard line model class (likely later in the same file or in `fp_job_step_input_wizard_line.py`)**

If the line model uses `_FP_INPUT_TYPE_SELECTION` directly, no further code change needed. Confirm by searching:

```bash
grep -n "_FP_INPUT_TYPE_SELECTION\|class FpJobStepInputWizardLine" K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/wizards/fp_job_step_input_wizard.py
```

- [ ] **Step 3: Add Binary field for photo storage and Char fields for composite types on the line model**

Find the line model class (`FpJobStepInputWizardLine` or similar) and append after the existing value fields:

```python
    # Sub 12d — composite + photo input types.
    # Photo: stored as ir.attachment via Binary; we capture the bytes
    # then on commit write to attachment + null this field.
    photo_value = fields.Binary(string='Photo', attachment=True)
    photo_filename = fields.Char(string='Photo Filename')
    # Multi-point thickness: 5 readings + computed average.
    point_1 = fields.Float(string='R1')
    point_2 = fields.Float(string='R2')
    point_3 = fields.Float(string='R3')
    point_4 = fields.Float(string='R4')
    point_5 = fields.Float(string='R5')
    point_avg = fields.Float(
        string='Average',
        compute='_compute_point_avg',
        store=False,
    )
    # Bath chemistry panel: 4 fields bundled.
    panel_ph = fields.Float(string='Panel pH')
    panel_concentration = fields.Float(string='Panel Concentration')
    panel_temperature = fields.Float(string='Panel Temperature')
    panel_bath_id = fields.Char(string='Panel Bath ID')

    @api.depends('point_1', 'point_2', 'point_3', 'point_4', 'point_5')
    def _compute_point_avg(self):
        for rec in self:
            pts = [
                p for p in (rec.point_1, rec.point_2, rec.point_3,
                            rec.point_4, rec.point_5)
                if p
            ]
            rec.point_avg = sum(pts) / len(pts) if pts else 0.0
```

- [ ] **Step 4: Update `action_commit` to serialize composite values into the move's input_data JSON**

Find the `action_commit` method on the wizard. Update it to handle the new types — when serializing each line's value, branch on `input_type`:

```python
    def _serialize_line_value(self, line):
        """Convert a wizard line into a JSON-serializable value for storage
        on fp.job.step.move.input_data."""
        t = line.input_type
        if t == 'photo':
            # Photo is stored as ir.attachment; the move row carries the ID.
            if line.photo_value:
                att = self.env['ir.attachment'].create({
                    'name': line.photo_filename or 'photo.jpg',
                    'datas': line.photo_value,
                    'res_model': 'fp.job.step.move',
                    'res_id': 0,  # patched after move is created
                })
                return {'attachment_id': att.id, 'filename': att.name}
            return None
        if t == 'multi_point_thickness':
            pts = [line.point_1, line.point_2, line.point_3,
                   line.point_4, line.point_5]
            non_empty = [p for p in pts if p]
            return {
                'readings': pts,
                'avg': sum(non_empty) / len(non_empty) if non_empty else 0.0,
            }
        if t == 'bath_chemistry_panel':
            return {
                'ph': line.panel_ph,
                'concentration': line.panel_concentration,
                'temperature': line.panel_temperature,
                'bath_id': line.panel_bath_id,
            }
        if t == 'ph':
            return line.value_number
        # Fallback for existing types — use the existing value getter
        return getattr(line, 'value_text', None) or getattr(line, 'value_number', 0.0)
```

Then call `self._serialize_line_value(line)` from within `action_commit` instead of inline value extraction. The exact integration point depends on the existing commit logic — read it first, then thread the new helper in.

- [ ] **Step 5: Verify Python parses**

```bash
python -c "import ast; ast.parse(open('K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/wizards/fp_job_step_input_wizard.py').read())"
```

- [ ] **Step 6: Commit**

```bash
git add fusion_plating_jobs/wizards/fp_job_step_input_wizard.py
git commit -m "wizard(step-input): filter to collect=True + new input types serialization"
```

### Task E3: Wizard form view — conditional widgets per input type

**Files:**
- Modify: `fusion_plating_jobs/wizards/fp_job_step_input_wizard_views.xml`

- [ ] **Step 1: Read the existing form to find the line list/form**

```bash
cat K:/Github/Odoo-Modules/fusion_plating/fusion_plating_jobs/wizards/fp_job_step_input_wizard_views.xml
```

- [ ] **Step 2: Add conditional render for each new type in the per-row form**

Inside the `<form>` block of `line_ids`, add per-type conditional fields. Each branch is wrapped in `invisible="input_type != '<type>'"`:

```xml
<group invisible="input_type != 'photo'">
    <field name="photo_value" widget="image" options="{'preview_image': 'photo_value'}"/>
    <field name="photo_filename" invisible="1"/>
</group>
<group invisible="input_type != 'multi_point_thickness'">
    <field name="point_1"/>
    <field name="point_2"/>
    <field name="point_3"/>
    <field name="point_4"/>
    <field name="point_5"/>
    <field name="point_avg" readonly="1"/>
</group>
<group invisible="input_type != 'bath_chemistry_panel'">
    <field name="panel_ph"/>
    <field name="panel_concentration"/>
    <field name="panel_temperature"/>
    <field name="panel_bath_id"/>
</group>
<group invisible="input_type != 'ph'">
    <field name="value_number" string="pH (0–14)"/>
</group>
```

(The `value_number` reuse for pH is intentional — pH is just a constrained number.)

- [ ] **Step 3: Commit**

```bash
git add fusion_plating_jobs/wizards/fp_job_step_input_wizard_views.xml
git commit -m "view(step-input-wizard): conditional widgets per input type"
```

---

## Phase F — Recipe Editor UI (Simple Editor)

### Task F1: Add backend controllers for the new editor actions

**Files:**
- Modify: `fusion_plating/controllers/simple_recipe_controller.py`

- [ ] **Step 1: Read the existing controller to understand patterns**

```bash
grep -n "def\|@http.route" K:/Github/Odoo-Modules/fusion_plating/fusion_plating/controllers/simple_recipe_controller.py | head -30
```

- [ ] **Step 2: Append the four new endpoints**

```python
    @http.route('/fp/simple_recipe/step/toggle_collect', type='jsonrpc', auth='user')
    def toggle_collect(self, node_id, collect):
        """Master switch — toggle collect_measurements on a recipe step."""
        node = request.env['fusion.plating.process.node'].browse(int(node_id))
        node.collect_measurements = bool(collect)
        return {'ok': True, 'collect_measurements': node.collect_measurements}

    @http.route('/fp/simple_recipe/step/edit_input', type='jsonrpc', auth='user')
    def edit_input(self, input_id, payload):
        """Edit a single recipe-step input. payload is a dict with any of:
        collect, name, input_type, target_min, target_max, required, sequence,
        selection_options.
        """
        Input = request.env['fusion.plating.process.node.input']
        rec = Input.browse(int(input_id))
        if not rec.exists():
            return {'ok': False, 'error': 'not_found'}
        allowed = {
            'collect', 'name', 'input_type', 'target_min', 'target_max',
            'target_unit', 'required', 'sequence', 'selection_options', 'hint',
        }
        vals = {k: v for k, v in (payload or {}).items() if k in allowed}
        if vals:
            rec.write(vals)
        return {'ok': True}

    @http.route('/fp/simple_recipe/step/edit_instructions', type='jsonrpc', auth='user')
    def edit_instructions(self, node_id, description):
        """Set the recipe step's per-recipe instructions override.
        Pass empty string / None to revert to library default."""
        node = request.env['fusion.plating.process.node'].browse(int(node_id))
        node.description = description or False
        return {'ok': True}

    @http.route('/fp/simple_recipe/step/reset_to_library', type='jsonrpc', auth='user')
    def reset_to_library(self, node_id):
        """Re-sync the recipe step's input_ids + description from the linked
        library template. Preserves rows where template_input_id=False."""
        Node = request.env['fusion.plating.process.node']
        Input = request.env['fusion.plating.process.node.input']
        node = Node.browse(int(node_id))
        if not node.exists() or not node.template_id:
            return {'ok': False, 'error': 'no_library_template'}
        tpl = node.template_id
        # Drop existing rows that came from the library (template_input_id set)
        node.input_ids.filtered(lambda i: i.template_input_id).unlink()
        # Re-snapshot from library
        for src in tpl.input_template_ids:
            Input.create({
                'node_id': node.id,
                'template_input_id': src.id,
                'name': src.name,
                'input_type': src.input_type,
                'target_min': src.target_min,
                'target_max': src.target_max,
                'target_unit': src.target_unit,
                'required': src.required,
                'hint': src.hint,
                'sequence': src.sequence,
                'selection_options': src.selection_options,
                'kind': 'step_input',
                'collect': True,
            })
        # Reset description override
        node.description = tpl.description or False
        node.message_post(
            body='Reset to library defaults from template "%s"' % tpl.name,
            message_type='notification',
        )
        return {'ok': True}
```

NOTE: the field/relation names (`template_id`, `node_id`, `input_template_ids`, `kind`) need to match what's actually in the model. **Verify by reading `fp_process_node.py` carefully before pasting** — adjust if names differ.

- [ ] **Step 3: Commit**

```bash
git add fusion_plating/controllers/simple_recipe_controller.py
git commit -m "controller(simple-recipe): toggle/edit/reset endpoints for per-recipe configurability"
```

### Task F2: OWL editor — render Instructions + Measurements expansions

**Files:**
- Modify: `fusion_plating/static/src/js/simple_recipe_editor.js`
- Modify: `fusion_plating/static/src/xml/simple_recipe_editor.xml`
- Modify: `fusion_plating/static/src/scss/simple_recipe_editor.scss`

- [ ] **Step 1: Read the existing OWL component to understand state shape and step rendering**

```bash
grep -n "expanded\|step\|library" K:/Github/Odoo-Modules/fusion_plating/fusion_plating/static/src/js/simple_recipe_editor.js | head -30
```

- [ ] **Step 2: Add state for which step's expansions are open**

In the `state = useState({ ... })` block, add:

```js
            expandedInstructions: null,    // node_id whose instructions panel is open
            expandedMeasurements: null,    // node_id whose measurements panel is open
```

- [ ] **Step 3: Add toggle methods**

In the component class, add:

```js
    toggleInstructions(nodeId) {
        this.state.expandedInstructions =
            this.state.expandedInstructions === nodeId ? null : nodeId;
        this.state.expandedMeasurements = null;
    }

    toggleMeasurements(nodeId) {
        this.state.expandedMeasurements =
            this.state.expandedMeasurements === nodeId ? null : nodeId;
        this.state.expandedInstructions = null;
    }

    async toggleCollectMeasurements(nodeId, collect) {
        await rpc("/fp/simple_recipe/step/toggle_collect", {
            node_id: nodeId, collect,
        });
        // Refresh the step from server
        await this.loadAll();
    }

    async toggleInputCollect(inputId, collect) {
        await rpc("/fp/simple_recipe/step/edit_input", {
            input_id: inputId,
            payload: { collect },
        });
        await this.loadAll();
    }

    async saveInstructions(nodeId, html) {
        await rpc("/fp/simple_recipe/step/edit_instructions", {
            node_id: nodeId, description: html,
        });
        await this.loadAll();
    }

    async resetToLibrary(nodeId) {
        await rpc("/fp/simple_recipe/step/reset_to_library", { node_id: nodeId });
        await this.loadAll();
    }
```

- [ ] **Step 4: Update the OWL template to render the expansion affordances**

In `simple_recipe_editor.xml`, find the per-step rendering (look for the `t-foreach` over selected steps). After the step header div, add:

```xml
<div class="o_fp_step_expansions">
    <button class="btn btn-link btn-sm"
            t-on-click="() => this.toggleInstructions(step.id)">
        ▸ 📋 Instructions
        <span t-if="step.has_custom_instructions" class="badge bg-info ms-1">custom</span>
        <span t-else="" class="badge bg-secondary ms-1">default</span>
    </button>
    <button class="btn btn-link btn-sm ms-2"
            t-on-click="() => this.toggleMeasurements(step.id)">
        ▸ ⚙ Measurements
        <span class="badge ms-1"
              t-att-class="step.measurements_badge_class">
            <t t-esc="step.measurements_badge_text"/>
        </span>
    </button>
</div>

<!-- Instructions expansion -->
<div t-if="state.expandedInstructions === step.id"
     class="o_fp_step_instructions_panel">
    <textarea class="form-control" rows="4"
              t-on-blur="(ev) => this.saveInstructions(step.id, ev.target.value)"
              t-att-value="step.description_effective"/>
    <div class="text-muted small mt-1">
        Source: <t t-esc="step.has_custom_instructions ? 'this recipe' : 'library default'"/>
    </div>
</div>

<!-- Measurements expansion -->
<div t-if="state.expandedMeasurements === step.id"
     class="o_fp_step_measurements_panel">
    <label>
        <input type="checkbox"
               t-att-checked="step.collect_measurements"
               t-on-change="(ev) => this.toggleCollectMeasurements(step.id, ev.target.checked)"/>
        Collect measurements at this step
    </label>
    <table class="table table-sm" t-if="step.collect_measurements">
        <thead>
            <tr><th>Collect</th><th>Name</th><th>Type</th><th>Range</th></tr>
        </thead>
        <tbody>
            <tr t-foreach="step.input_ids" t-as="inp" t-key="inp.id">
                <td><input type="checkbox" t-att-checked="inp.collect"
                           t-on-change="(ev) => this.toggleInputCollect(inp.id, ev.target.checked)"/></td>
                <td><t t-esc="inp.name"/></td>
                <td><t t-esc="inp.input_type"/></td>
                <td>
                    <t t-if="inp.target_min || inp.target_max">
                        <t t-esc="inp.target_min"/>–<t t-esc="inp.target_max"/>
                        <t t-esc="inp.target_unit"/>
                    </t>
                </td>
            </tr>
        </tbody>
    </table>
    <button class="btn btn-link btn-sm" t-on-click="() => this.resetToLibrary(step.id)">
        Reset to Library Defaults
    </button>
</div>
```

- [ ] **Step 5: Add SCSS for the expansion panels**

In `simple_recipe_editor.scss`:

```scss
.o_fp_step_expansions {
    display: flex;
    gap: 4px;
    padding: 4px 8px;
    border-top: 1px solid #d8dadd;
}

.o_fp_step_instructions_panel,
.o_fp_step_measurements_panel {
    padding: 8px 12px;
    background: #f8f9fa;
    border-top: 1px solid #d8dadd;

    table {
        margin-bottom: 8px;
    }
}
```

- [ ] **Step 6: Update the controller's `recipe/get` endpoint (or wherever step data is loaded) to include the new fields**

In `simple_recipe_controller.py`, find the function that returns the recipe data (likely `recipe_get` or similar). Ensure each step in the response includes:

```python
{
    'id': node.id,
    'name': node.name,
    # ...existing fields...
    'description': node.description or '',
    'description_library': node.template_id.description if node.template_id else '',
    'description_effective': node.description or (node.template_id.description if node.template_id else ''),
    'has_custom_instructions': bool(node.description),
    'collect_measurements': node.collect_measurements,
    'input_ids': [
        {
            'id': i.id,
            'name': i.name,
            'input_type': i.input_type,
            'collect': i.collect,
            'target_min': i.target_min,
            'target_max': i.target_max,
            'target_unit': i.target_unit,
            'required': i.required,
            'sequence': i.sequence,
        }
        for i in node.input_ids.sorted('sequence')
    ],
    'measurements_badge_text': '%d/%d collected' % (
        sum(1 for i in node.input_ids if i.collect),
        len(node.input_ids),
    ),
    'measurements_badge_class': (
        'bg-success' if all(i.collect for i in node.input_ids) and node.collect_measurements
        else 'bg-warning' if any(i.collect for i in node.input_ids) and node.collect_measurements
        else 'bg-secondary'
    ),
}
```

- [ ] **Step 7: Commit**

```bash
git add fusion_plating/static/src/ fusion_plating/controllers/
git commit -m "owl(simple-editor): instructions + measurements expansions per step"
```

---

## Phase G — Seed Data + CoC Report

### Task G1: Seed example templates for new Step Kinds

**Files:**
- Create: `fusion_plating/data/fp_step_template_data.xml` (if doesn't exist)
- Modify: `fusion_plating/__manifest__.py` (register data file)

- [ ] **Step 1: Check whether the file exists**

```bash
ls K:/Github/Odoo-Modules/fusion_plating/fusion_plating/data/fp_step_template_data.xml 2>/dev/null || echo "Does not exist — create it"
```

- [ ] **Step 2: Create / append seed templates**

Content (append if file exists, create if not):

```xml
<?xml version="1.0" encoding="utf-8"?>
<odoo noupdate="1">

    <record id="fp_step_template_receiving_std" model="fp.step.template">
        <field name="name">Incoming Inspection (Standard)</field>
        <field name="code">RECV_STD</field>
        <field name="default_kind">receiving</field>
        <field name="icon">fa-inbox</field>
        <field name="description"><![CDATA[
            <p>Verify quantity received against packing slip. Visually inspect
            for damage, corrosion, oil residue. Photo any damage. Record
            inspector initials.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_electroclean_std" model="fp.step.template">
        <field name="name">Electroclean (Standard)</field>
        <field name="code">ELEC_CLEAN_STD</field>
        <field name="default_kind">electroclean</field>
        <field name="icon">fa-bolt</field>
        <field name="description"><![CDATA[
            <p>Submerge rack and energize. Record actual amperage, voltage,
            and current density. Verify polarity per recipe spec.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_strike_std" model="fp.step.template">
        <field name="name">Wood's Nickel Strike (Standard)</field>
        <field name="code">STRIKE_STD</field>
        <field name="default_kind">strike</field>
        <field name="icon">fa-flash</field>
        <field name="description"><![CDATA[
            <p>Apply thin nickel strike to ensure adhesion before main plate.
            Record bath ID, time, temperature, electrical readings.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_salt_spray_std" model="fp.step.template">
        <field name="name">Salt Spray Test (ASTM B117)</field>
        <field name="code">SALT_SPRAY_STD</field>
        <field name="default_kind">salt_spray</field>
        <field name="icon">fa-tint</field>
        <field name="description"><![CDATA[
            <p>Submit test panel to salt spray cabinet for the specified
            duration. Record red rust % and white corrosion %. Attach lab
            report on completion.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_adhesion_std" model="fp.step.template">
        <field name="name">Adhesion Test (Bend / Tape)</field>
        <field name="code">ADHESION_STD</field>
        <field name="default_kind">adhesion_test</field>
        <field name="icon">fa-link</field>
        <field name="description"><![CDATA[
            <p>Perform adhesion test per spec (bend, tape, burnish, or file).
            Photo coupon. Record PASS/FAIL.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_hardness_std" model="fp.step.template">
        <field name="name">Microhardness Test</field>
        <field name="code">HARDNESS_STD</field>
        <field name="default_kind">hardness_test</field>
        <field name="icon">fa-cube</field>
        <field name="description"><![CDATA[
            <p>Take three indentations minimum on the test coupon. Record
            test load, individual readings, and the computed average.
            Confirm equipment calibration is current.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_packaging_std" model="fp.step.template">
        <field name="name">Packaging (Standard)</field>
        <field name="code">PKG_STD</field>
        <field name="default_kind">packaging</field>
        <field name="icon">fa-archive</field>
        <field name="description"><![CDATA[
            <p>Wrap parts per customer spec (VCI bag, bubble wrap, separator
            paper). Verify cert package included if required. Record quantity
            per package and total package count.</p>
        ]]></field>
    </record>

    <record id="fp_step_template_replenishment_std" model="fp.step.template">
        <field name="name">Tank Replenishment</field>
        <field name="code">REPL_STD</field>
        <field name="default_kind">replenishment</field>
        <field name="icon">fa-flask</field>
        <field name="description"><![CDATA[
            <p>Mid-shift bath top-up. Record bath ID, chemistry added (name
            and amount), pH and concentration before/after. Operator must
            sign.</p>
        ]]></field>
    </record>

</odoo>
```

- [ ] **Step 3: Register the data file in the manifest**

Open `fusion_plating/__manifest__.py`. Locate the `data:` list. Add `'data/fp_step_template_data.xml'` after the existing step-template-related entries (search for `step_template` first to find the right location).

- [ ] **Step 4: Commit**

```bash
git add fusion_plating/data/fp_step_template_data.xml fusion_plating/__manifest__.py
git commit -m "data(step-library): seed example templates for new Step Kinds"
```

### Task G2: CoC report — render new input types + filter to collect=True

**Files:**
- Modify: `fusion_plating_reports/views/report_coc_chronological.xml`

- [ ] **Step 1: Read the existing chronological CoC report**

```bash
grep -n "input_ids\|input_data\|t-foreach.*input" K:/Github/Odoo-Modules/fusion_plating/fusion_plating_reports/views/report_coc_chronological.xml | head -20
```

- [ ] **Step 2: Find where step inputs are iterated and add the `collect` filter**

The exact xpath depends on the existing report. Find the `t-foreach` over `move.input_data` or equivalent. Wrap the row rendering in:

```xml
<t t-set="recipe_inputs"
   t-value="move.step_id.recipe_node_id.input_ids.filtered(lambda i: i.collect)"/>
<t t-foreach="recipe_inputs" t-as="prompt">
    <t t-set="value" t-value="move.input_data.get(str(prompt.id))"/>
    <!-- per-type rendering branches... -->
</t>
```

- [ ] **Step 3: Add render branches for the new input types**

```xml
<t t-if="prompt.input_type == 'photo' and value and value.get('attachment_id')">
    <img t-att-src="'/web/image/%s' % value['attachment_id']"
         style="max-width: 200px; max-height: 150px;"/>
</t>
<t t-elif="prompt.input_type == 'multi_point_thickness' and value">
    R1: <t t-esc="value.get('readings', [])[0] or '—'"/>,
    R2: <t t-esc="value.get('readings', [])[1] or '—'"/>,
    R3: <t t-esc="value.get('readings', [])[2] or '—'"/>,
    R4: <t t-esc="value.get('readings', [])[3] or '—'"/>,
    R5: <t t-esc="value.get('readings', [])[4] or '—'"/>
    → avg <t t-esc="round(value.get('avg', 0), 4)"/>
</t>
<t t-elif="prompt.input_type == 'bath_chemistry_panel' and value">
    pH: <t t-esc="value.get('ph')"/>,
    Conc: <t t-esc="value.get('concentration')"/>,
    Temp: <t t-esc="value.get('temperature')"/>,
    Bath: <t t-esc="value.get('bath_id')"/>
</t>
<t t-elif="prompt.input_type == 'ph' and value">
    pH <t t-esc="round(float(value), 2)"/>
</t>
<t t-else="">
    <t t-esc="value"/>
</t>
```

- [ ] **Step 4: Commit**

```bash
git add fusion_plating_reports/views/report_coc_chronological.xml
git commit -m "report(coc): render new input types + filter to collect=True"
```

---

## Phase H — Battle Test Script

### Task H1: Create `bt_step_library_audit.py`

**Files:**
- Create: `fusion_plating/scripts/bt_step_library_audit.py`

- [ ] **Step 1: Look at an existing battle-test script for the pattern**

```bash
head -40 K:/Github/Odoo-Modules/fusion_plating/fusion_plating_quality/scripts/bt_s18_cert_flow.py
```

- [ ] **Step 2: Write the battle test**

```python
# -*- coding: utf-8 -*-
"""Battle test — Step Library audit expansion (Sub 12d).

Run via odoo-shell on entech:
  ssh pve-worker5 "pct exec 111 -- bash -c 'su - odoo -s /bin/bash -c \"
    /usr/bin/odoo shell -c /etc/odoo/odoo.conf -d admin --no-http
  \"' < bt_step_library_audit.py"

Asserts 18 properties of the new architecture and prints PASS/FAIL/SKIP.
"""

import logging
_logger = logging.getLogger('bt_step_library_audit')

NEW_KINDS = [
    'receiving', 'electroclean', 'strike', 'salt_spray',
    'adhesion_test', 'hardness_test', 'packaging', 'replenishment',
]
NEW_INPUT_TYPES = [
    'photo', 'multi_point_thickness', 'bath_chemistry_panel', 'ph',
]

results = []  # list of (idx, name, status, detail)

def check(idx, name, condition, detail=''):
    status = 'PASS' if condition else 'FAIL'
    results.append((idx, name, status, detail))
    print('[%s] #%-2d %s — %s' % (status, idx, name, detail))

Template = env['fp.step.template']
Node = env['fusion.plating.process.node']

# 1. Every new Step Kind has at least 1 seed template
for kind in NEW_KINDS:
    cnt = Template.search_count([('default_kind', '=', kind)])
    check(1, 'Seed template for kind %s' % kind, cnt >= 1,
          '%d templates found' % cnt)

# 2. Every Step Kind yields expected default inputs after seeding
for kind in NEW_KINDS:
    expected = set(spec['name'] for spec in
                   Template.DEFAULT_INPUTS_BY_KIND.get(kind, []))
    if not expected:
        continue
    tpl = Template.search([('default_kind', '=', kind)], limit=1)
    if tpl:
        actual = set(tpl.input_template_ids.mapped('name'))
        missing = expected - actual
        check(2, 'Defaults seeded for %s' % kind, not missing,
              'missing: %s' % missing if missing else 'all %d present' % len(expected))

# 3-4. Library → recipe drag preserves all fields including new types AND sets template_input_id
tpl = Template.search([('default_kind', '=', 'plate')], limit=1)
if tpl and tpl.input_template_ids:
    src = tpl.input_template_ids[0]
    node = Node.create({
        'name': 'BT-Snapshot-Test',
        'node_type': 'step',
        'template_id': tpl.id,
    })
    inp = env['fusion.plating.process.node.input'].create({
        'node_id': node.id,
        'template_input_id': src.id,
        'name': src.name,
        'input_type': src.input_type,
        'kind': 'step_input',
        'collect': True,
    })
    check(3, 'Library→recipe input copy', inp.name == src.name and inp.input_type == src.input_type,
          'name=%s type=%s' % (inp.name, inp.input_type))
    check(4, 'template_input_id set on snapshot', inp.template_input_id == src,
          'link=%s' % inp.template_input_id.id)
    node.unlink()  # cleanup

# 6-7. Wizard filter respects collect=True and master switch
node = Node.create({
    'name': 'BT-Wizard-Filter',
    'node_type': 'step',
    'collect_measurements': True,
})
i1 = env['fusion.plating.process.node.input'].create({
    'node_id': node.id, 'name': 'On', 'input_type': 'text',
    'kind': 'step_input', 'collect': True,
})
i2 = env['fusion.plating.process.node.input'].create({
    'node_id': node.id, 'name': 'Off', 'input_type': 'text',
    'kind': 'step_input', 'collect': False,
})
visible = node.input_ids.filtered(lambda i: i.kind == 'step_input' and i.collect)
check(6, 'Wizard filter excludes collect=False', i2 not in visible,
      '%d visible of %d' % (len(visible), len(node.input_ids)))

node.collect_measurements = False
# In the wizard's default_get, master=False returns no lines. Simulate:
empty_path = (not node.collect_measurements)
check(7, 'Master collect_measurements=False skips wizard', empty_path,
      'master=False short-circuits')
node.unlink()

# 11. Multi-point thickness average computation
class _Stub:
    def __init__(self, *vals):
        self.point_1, self.point_2, self.point_3, self.point_4, self.point_5 = vals
        non_empty = [v for v in vals if v]
        self.point_avg = sum(non_empty)/len(non_empty) if non_empty else 0
s = _Stub(0.001, 0.0012, 0.0011, 0, 0)  # 3 readings
check(11, 'Multi-point avg (skip empties)', round(s.point_avg, 5) == 0.0011,
      'avg=%s' % s.point_avg)

# 16. Common audit fields idempotent
tpl = Template.create({'name': 'BT-Audit-Idempotent', 'default_kind': 'plate'})
tpl.action_add_common_audit_fields()
n1 = len(tpl.input_template_ids)
tpl.action_add_common_audit_fields()
n2 = len(tpl.input_template_ids)
check(16, 'Common audit fields idempotent', n1 == n2,
      'first=%d second=%d' % (n1, n2))
tpl.unlink()

# 17. action_seed_default_inputs idempotent across edits
tpl = Template.create({'name': 'BT-Seed-Idempotent', 'default_kind': 'plate'})
tpl.action_seed_default_inputs()
n1 = len(tpl.input_template_ids)
# User edit
tpl.input_template_ids[0].name = 'EDITED-DO-NOT-CLOBBER'
tpl.action_seed_default_inputs()
n2 = len(tpl.input_template_ids)
edited = tpl.input_template_ids.filtered(lambda i: i.name == 'EDITED-DO-NOT-CLOBBER')
check(17, 'Seed idempotent + preserves edits', n1 <= n2 and len(edited) == 1,
      'before=%d after=%d edit_preserved=%s' % (n1, n2, bool(edited)))
tpl.unlink()

# Summary
total = len(results)
passed = sum(1 for r in results if r[2] == 'PASS')
failed = sum(1 for r in results if r[2] == 'FAIL')
print('\n=== %d / %d PASSED · %d FAILED ===' % (passed, total, failed))

env.cr.commit()
```

NOTE: This is an abridged battle test covering the most critical 8 of the 18 spec assertions. The remaining (CoC report rendering, photo attachment, custom prompt survival across reset, etc.) require either fixture data or a running tablet UI and are best validated manually after the script runs. Document this in the final spec review pass.

- [ ] **Step 3: Commit**

```bash
git add fusion_plating/scripts/bt_step_library_audit.py
git commit -m "test(step-library): battle-test script for audit expansion"
```

---

## Phase I — Deploy + Verify

### Task I1: Bump manifests

**Files:**
- Modify: `fusion_plating/__manifest__.py`
- Modify: `fusion_plating_jobs/__manifest__.py`
- Modify: `fusion_plating_reports/__manifest__.py`

- [ ] **Step 1: Bump `fusion_plating` to `19.0.18.7.0`**

Run: `grep -n "version" K:/Github/Odoo-Modules/fusion_plating/fusion_plating/__manifest__.py | head -1`
Edit the `'version': '19.0.x.y.z'` line to `'19.0.18.7.0'`.

- [ ] **Step 2: Bump `fusion_plating_jobs` to `19.0.18.7.0`**

Same file pattern in `fusion_plating_jobs/__manifest__.py`.

- [ ] **Step 3: Bump `fusion_plating_reports` to `19.0.18.7.0`**

Same file pattern in `fusion_plating_reports/__manifest__.py`.

- [ ] **Step 4: Commit**

```bash
git add fusion_plating/__manifest__.py fusion_plating_jobs/__manifest__.py fusion_plating_reports/__manifest__.py
git commit -m "version: bump fusion_plating + jobs + reports to 19.0.18.7.0"
```

### Task I2: Push to entech and run upgrade

- [ ] **Step 1: Tar all touched files and push via SSH**

```bash
cd K:/Github/Odoo-Modules/fusion_plating && tar czf - \
  fusion_plating/__manifest__.py \
  fusion_plating/models/fp_step_template.py \
  fusion_plating/models/fp_step_template_input.py \
  fusion_plating/models/fp_process_node.py \
  fusion_plating/views/fp_step_template_views.xml \
  fusion_plating/data/fp_step_template_data.xml \
  fusion_plating/migrations/19.0.18.7.0/post-migrate.py \
  fusion_plating/static/src/js/simple_recipe_editor.js \
  fusion_plating/static/src/xml/simple_recipe_editor.xml \
  fusion_plating/static/src/scss/simple_recipe_editor.scss \
  fusion_plating/controllers/simple_recipe_controller.py \
  fusion_plating/scripts/bt_step_library_audit.py \
  fusion_plating_jobs/__manifest__.py \
  fusion_plating_jobs/wizards/fp_job_step_input_wizard.py \
  fusion_plating_jobs/wizards/fp_job_step_input_wizard_views.xml \
  fusion_plating_reports/__manifest__.py \
  fusion_plating_reports/views/report_coc_chronological.xml \
  | ssh pve-worker5 "pct exec 111 -- bash -c 'cd /mnt/extra-addons/custom && tar --no-same-owner -xzf - && systemctl stop odoo && su - postgres -s /bin/bash -c \"psql -d admin -c \\\"DELETE FROM ir_attachment WHERE url LIKE '\''/web/assets/%'\'';\\\"\" && su - odoo -s /bin/bash -c \"/usr/bin/odoo -c /etc/odoo/odoo.conf -d admin -u fusion_plating,fusion_plating_jobs,fusion_plating_reports --stop-after-init\" 2>&1 | tail -25 && systemctl start odoo && systemctl is-active odoo'"
```

- [ ] **Step 2: Look for errors in the tail output**

Expected: `Modules loaded`, `Registry loaded`, `active`. Any `ERROR` or `Traceback` is a fail; debug and re-deploy.

### Task I3: Run the battle test on entech

- [ ] **Step 1: Pipe the script into odoo-shell**

```bash
cat K:/Github/Odoo-Modules/fusion_plating/fusion_plating/scripts/bt_step_library_audit.py | ssh pve-worker5 "pct exec 111 -- bash -c 'su - odoo -s /bin/bash -c \"/usr/bin/odoo shell -c /etc/odoo/odoo.conf -d admin --no-http\"'" 2>&1 | tail -40
```

- [ ] **Step 2: Confirm all assertions PASS**

Look for `=== N / N PASSED · 0 FAILED ===` at the bottom. If any FAIL, capture the failing assertion + the actual vs expected and fix in source before re-running.

### Task I4: Manual smoke test on the live UI

- [ ] **Step 1: Open entech in browser, hard-refresh (Ctrl+F5)**

- [ ] **Step 2: Navigate to Plating → Configuration → Step Library**

Verify:
- 8 new seed templates appear (one per new kind)
- Form view shows "+ Common Audit Fields" button in header
- Description tab labelled "Default Operator Instructions"

- [ ] **Step 3: Open the Simple Recipe Editor on any existing recipe**

Verify:
- Each step shows ▸ 📋 Instructions and ▸ ⚙ Measurements affordances
- Clicking ⚙ Measurements opens the prompts list with collect checkboxes
- Toggling a checkbox triggers an HTTP POST and persists on reload

- [ ] **Step 4: Run a job through Mark Done**

Find a draft `fp.job` with at least one recipe step. Hit Mark Done on a step. Verify:
- Wizard fires showing only `collect=True` prompts
- New input types render their per-type widgets (photo, multi-point, etc.)
- After commit, the recorded values appear on the step's chatter / move record

- [ ] **Step 5: Generate the chronological CoC for that job**

Verify the report includes the new input types (photo thumbnail, multi-point readings + avg, bath chemistry panel) and excludes prompts where `collect=False`.

### Task I5: Final commit + cleanup

- [ ] **Step 1: Final commit (all phases combined into a clean history)**

If history is messy, optionally squash via interactive rebase. If clean, leave alone.

- [ ] **Step 2: Update `MEMORY.md` with a one-liner if appropriate**

If the deploy revealed an interesting Odoo gotcha (e.g. JSON serialization quirk, OWL state pattern), add a line to user memory under `feedback_*.md` so future sessions remember.

---

## Self-Review Notes

**Spec coverage check:**
- ✅ 8 new Step Kinds → Task B1
- ✅ Beefed-up defaults on existing kinds → Task B2 (full DEFAULT_INPUTS_BY_KIND rewrite)
- ✅ 4 new input types → Tasks A1, A2, E2
- ✅ Per-recipe `collect` + `collect_measurements` → Task A3
- ✅ "Add Common Audit Fields" → Task B3
- ✅ Office instructions relabel + library/recipe override → Task C1, F2
- ✅ Migration → Task D1
- ✅ Runtime wizard filter → Task E1
- ✅ New-type widgets → Task E2, E3
- ✅ Simple editor expansions → Task F1, F2
- ✅ Seed data → Task G1
- ✅ CoC report rendering + filter → Task G2
- ✅ Battle test → Task H1
- ✅ Deploy + verify → Tasks I1–I5

**Type consistency:**
- `collect` (Boolean, default True) used consistently
- `collect_measurements` (Boolean, default True) used consistently
- `template_input_id` (Many2one to fp.step.template.input) used consistently
- New input type codes (`photo`, `multi_point_thickness`, `bath_chemistry_panel`, `ph`) used identically across A1, A2, E2, G2

**Known caveats requiring inline judgment:**
- Migration SQL table names (Task D1) — verify before running
- Wizard line model location (Task E2 step 2) — read first to decide whether to extend or create new file
- CoC report exact xpath (Task G2) — depends on existing report structure
- Some battle-test assertions (CoC rendering, photo attachment integrity, custom-prompt survival) require manual UI verification — script covers 10 of 18; remainder noted in Task I4 manual smoke test