netbox-super-cli 1.6.0__tar.gz → 1.6.2__tar.gz

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 All notable changes to netbox-super-cli are tracked here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) loosely. From v1.0.0 onward, releases follow [Semantic Versioning](https://semver.org/) and the version in `pyproject.toml` matches the git tag. Pre-1.0 milestones (Phase 1-5) were pinned by tag while `pyproject.toml` stayed at `0.0.1`.
 
+## v1.6.2 — 2026-06-30
+
+Patch release. Fixes TUI foreign-key pickers resolving to the wrong resource.
+
+### Fixed
+
+- **Filtering/editing by `role` (and other FKs) opened the wrong picker**
+  ([#139]). Choosing a `role` value when filtering devices listed IPAM roles
+  instead of device roles, because the picker matched the bare field name across
+  apps. Foreign-key pickers now resolve to the field's true target read from the
+  OpenAPI schema (a device/VM `role` → dcim device-roles, a prefix `role` → ipam
+  roles, a contact-assignment `role` → tenancy contact-roles), and fall back to a
+  context-qualified name match. This also corrects `group`, `type`, and similar
+  cross-app FK fields. Cached schemas rebuild once to pick up the new metadata.
+
+[#139]: https://github.com/thomaschristory/netbox-super-cli/issues/139
+
+## v1.6.1 — 2026-06-29
+
+Patch release. Fixes the TUI bulk-edit form so custom-field edits are visible and
+actually save.
+
+### Fixed
+
+- **Bulk-edit include toggles were invisible, so edits silently didn't save**
+  ([#137]). The per-field include switch in the bulk-edit form was clipped to
+  zero width by its stylesheet and rendered blank — users couldn't see or flip
+  it, so no field was opted in and the apply produced no change with no error.
+  The toggle now sizes to fit its slider.
+- **Edit forms showed the raw `custom_fields.<name>` key** ([#137]). The
+  single-edit and bulk-edit forms, and the change-preview diff, now show a custom
+  field's human label (e.g. "Site Contact") instead of the raw dotted key,
+  matching the list-column labels added in v1.6.0.
+- **Opting in a custom-field select with an unresolved choice set could silently
+  null the field** ([#137]). A select whose choices couldn't be fetched rendered
+  empty; opting it in seeded a null and cleared a value the user never edited.
+  Opting in a blank select now contributes no change; only the explicit ∅ button
+  nulls.
+- **Bulk-editing a shared custom field could overwrite it on opt-in** ([#137]).
+  Custom-field widgets didn't seed the value the selected records share, so a
+  shared boolean rendered as `False` and opting it in unchanged flipped every
+  record to `False` (and a shared multiselect cleared to empty). Custom-field
+  widgets now seed the shared value, so opting a field in without editing it is a
+  no-op.
+
+[#137]: https://github.com/thomaschristory/netbox-super-cli/issues/137
+
 ## v1.6.0 — 2026-06-29
 
 Minor release. The interactive TUI gets human-readable custom-field columns,

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-super-cli
-Version: 1.6.0
+Version: 1.6.2
 Summary: Dynamic NetBox CLI generated from the live OpenAPI schema.
 Project-URL: Homepage, https://github.com/thomaschristory/netbox-super-cli
 Project-URL: Documentation, https://thomaschristory.github.io/netbox-super-cli/

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/docs/guides/interactive-tui.md

@@ -144,9 +144,11 @@ endpoint can filter by this one. Switch tabs with <kbd>Tab</kbd> and press
 ## Bulk editing
 
 Select rows on a list with <kbd>v</kbd>/<kbd>Space</kbd>, then press
-<kbd>B</kbd>. Choose *which* fields to set (each has an include toggle) and one
-value each. Fields are **prepopulated** with the value the selected records
-share, so a small tweak doesn't mean retyping.
+<kbd>B</kbd>. Each field is one row: flip its **include toggle** (the switch on
+the left) to opt it into the change, then set its value — a field with the toggle
+off is left untouched. Custom fields appear as individual rows under their human
+label. Fields are **prepopulated** with the value the selected records share, so
+a small tweak doesn't mean retyping.
 
 Press <kbd>p</kbd> to **preview** — a per-record diff of exactly what will
 change (records already matching are left untouched). Confirm to apply; a

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/_version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the package version."""
 
-__version__ = "1.6.0"
+__version__ = "1.6.2"

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/builder/build.py

@@ -10,8 +10,10 @@ import re
 from typing import Literal
 
 from nsc.model.command_model import (
+    MODEL_FORMAT_VERSION,
     CommandModel,
     FieldShape,
+    FkResourceRef,
     HttpMethod,
     Operation,
     Parameter,
@@ -77,6 +79,8 @@ def build_command_model(loaded: LoadedSchema) -> CommandModel:
         info_version=doc.info.version,
         schema_hash=loaded.hash,
         tags=final_tags,
+        fk_resources=_build_fk_resources(doc),
+        format_version=MODEL_FORMAT_VERSION,
     )
 
 
@@ -346,10 +350,107 @@ def _flat_fields(schema: SchemaObject, doc: OpenAPIDocument) -> dict[str, FieldS
         resolved = _resolve_ref(prop, doc) or prop
         primitive = _primitive(resolved)
         enum = [str(v) for v in resolved.enum] if resolved.enum else None
-        out[name] = FieldShape(primitive=primitive, enum=enum, nullable=resolved.nullable)
+        out[name] = FieldShape(
+            primitive=primitive,
+            enum=enum,
+            nullable=resolved.nullable,
+            fk_target=_fk_target_component(prop),
+        )
     return out
 
 
+def _ref_component_name(ref: str | None) -> str | None:
+    prefix = "#/components/schemas/"
+    if isinstance(ref, str) and ref.startswith(prefix):
+        return ref[len(prefix) :]
+    return None
+
+
+def _normalize_serializer(name: str) -> str:
+    """Reduce a serializer name to a key shared by a field's FK brief and the
+    target resource's list serializer: ``BriefDeviceRoleRequest`` → ``DeviceRole``
+    and ``DeviceWithConfigContext`` → ``Device`` both land on the same base."""
+    return name.removeprefix("Brief").removesuffix("Request").removesuffix("WithConfigContext")
+
+
+def _branch_ref(raw: dict[str, object]) -> str | None:
+    """The `$ref` of a oneOf/anyOf branch, unwrapping a nullable `allOf` wrapper."""
+    ref = raw.get("$ref")
+    if isinstance(ref, str):
+        return ref
+    inner = raw.get("allOf")
+    if isinstance(inner, list):
+        for sub in inner:
+            if isinstance(sub, dict) and isinstance(sub.get("$ref"), str):
+                return str(sub["$ref"])
+    return None
+
+
+def _fk_target_component(prop: SchemaObject) -> str | None:
+    """Target serializer name for a writable FK (`oneOf[integer, Brief<X>Request]`).
+
+    A `oneOf`/`anyOf` mixing an integer branch with a brief-ref branch is NetBox's
+    way of saying "an id or an object" — i.e. a foreign key. Returns `<X>`.
+    """
+    extras = prop.model_extra or {}
+    branches = extras.get("oneOf") or extras.get("anyOf") or []
+    if not isinstance(branches, list):
+        return None
+    has_integer = False
+    ref_name: str | None = None
+    for raw in branches:
+        if not isinstance(raw, dict):
+            continue
+        if raw.get("type") == "integer":
+            has_integer = True
+        name = _ref_component_name(_branch_ref(raw))
+        if name is not None:
+            ref_name = name
+    if has_integer and ref_name is not None:
+        return _normalize_serializer(ref_name)
+    return None
+
+
+def _list_serializer_name(get_op: SchemaOperation, doc: OpenAPIDocument) -> str | None:
+    """The item serializer name a collection GET returns (Paginated<X>List → <X>)."""
+    response = get_op.responses.get("200")
+    if response is None:
+        return None
+    media = response.content.get("application/json")
+    if media is None or media.schema_ is None:
+        return None
+    paginated_name = _ref_component_name(media.schema_.ref)
+    if paginated_name is None:
+        return None
+    paginated = doc.components.schemas.get(paginated_name)
+    if paginated is None or not paginated.properties:
+        return None
+    results = paginated.properties.get("results")
+    if results is None or results.items is None:
+        return None
+    return _ref_component_name(results.items.ref)
+
+
+def _build_fk_resources(doc: OpenAPIDocument) -> dict[str, FkResourceRef]:
+    """Index each list endpoint's item serializer to its owning resource."""
+    index: dict[str, FkResourceRef] = {}
+    for path in sorted(doc.paths):
+        get_op = doc.paths[path].get
+        if get_op is None or not get_op.tags:
+            continue
+        tag_name = get_op.tags[0]
+        resource_name, is_collection = _resource_from_path(path, tag_name)
+        if resource_name is None or not is_collection:
+            continue
+        serializer = _list_serializer_name(get_op, doc)
+        if serializer is None:
+            continue
+        index.setdefault(
+            _normalize_serializer(serializer), FkResourceRef(tag=tag_name, resource=resource_name)
+        )
+    return index
+
+
 def _primitive(schema: SchemaObject) -> PrimitiveType:
     if schema.type is None:
         return PrimitiveType.UNKNOWN

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/cache/store.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from nsc.config.models import Config, Profile
-from nsc.model.command_model import CommandModel
+from nsc.model.command_model import MODEL_FORMAT_VERSION, CommandModel
 
 _LOG = logging.getLogger(__name__)
 _PROFILE_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$")
@@ -76,6 +76,10 @@ class CacheStore:
         if model.schema_hash != schema_hash:
             _LOG.warning("cache: hash mismatch for %s (file says %s)", target, model.schema_hash)
             return None
+        if model.format_version != MODEL_FORMAT_VERSION:
+            # Built by an older nsc whose model lacks current metadata; rebuild.
+            _LOG.info("cache: stale model format for %s; rebuilding", target)
+            return None
         return model
 
     def save(self, profile: str, model: CommandModel) -> Path:

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/model/command_model.py

@@ -43,6 +43,12 @@ class PrimitiveType(StrEnum):
     UNKNOWN = "unknown"
 
 
+# Bumped whenever the builder changes the shape of a CommandModel in a way that
+# makes older cached models incomplete (not just a schema-body change). The cache
+# rebuilds entries stamped with an older version. See nsc/cache/store.py.
+MODEL_FORMAT_VERSION = 1
+
+
 class _Frozen(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
@@ -60,6 +66,10 @@ class FieldShape(_Frozen):
     primitive: PrimitiveType = PrimitiveType.UNKNOWN
     enum: list[str] | None = None
     nullable: bool = False
+    # For a writable foreign key (`oneOf[integer, Brief<X>Request]`), the target
+    # serializer name `<X>` (e.g. "DeviceRole"); None for non-FK fields. Pairs
+    # with CommandModel.fk_resources to find the target resource.
+    fk_target: str | None = None
 
 
 class RequestBodyShape(_Frozen):
@@ -97,6 +107,13 @@ class Tag(_Frozen):
     resources: dict[str, Resource] = Field(default_factory=dict)
 
 
+class FkResourceRef(_Frozen):
+    """Where a foreign-key serializer lives: which `tag` and `resource` serve it."""
+
+    tag: str
+    resource: str
+
+
 class CommandModel(_Frozen):
     """The full normalized tree: tags → resources → operations."""
 
@@ -104,6 +121,11 @@ class CommandModel(_Frozen):
     info_version: str
     schema_hash: str
     tags: dict[str, Tag] = Field(default_factory=dict)
+    # serializer name (e.g. "DeviceRole") → the resource whose list endpoint
+    # serves it. Lets the TUI resolve an FK picker to its true target.
+    fk_resources: dict[str, FkResourceRef] = Field(default_factory=dict)
+    # Defaults to 0 so models written before versioning read as stale and rebuild.
+    format_version: int = 0
 
     def iter_operations(self) -> Iterator[tuple[str, str, Operation]]:
         """Yield `(tag, resource, operation)` triples in deterministic order."""

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/tui/bulk.py

@@ -29,6 +29,7 @@ def bulk_diff(
     bulk_set: dict[str, object],
     sensitive_paths: tuple[str, ...],
     new_displays: dict[str, str] | None = None,
+    field_labels: dict[str, str] | None = None,
 ) -> list[RecordChange]:
     """Compute the per-record patch and diff rows for a uniform bulk ``set``.
 
@@ -36,12 +37,13 @@ def bulk_diff(
     record's current value contributes no patch entry and no row for that
     record, so heterogeneous current values yield different changed subsets.
     ``new_displays`` maps a field to the human label of its chosen FK value so
-    the diff renders the name rather than the id.
+    the diff renders the name rather than the id. ``field_labels`` maps a field
+    key to its human label so ``custom_fields.<name>`` rows aren't shown raw.
     """
     changes: list[RecordChange] = []
     for record in selected:
         patch = compute_patch(record, bulk_set)
-        rows = diff_rows(record, patch, sensitive_paths, new_displays)
+        rows = diff_rows(record, patch, sensitive_paths, new_displays, field_labels)
         changes.append(RecordChange(record_id=record.get("id"), patch=patch, rows=rows))
     return changes
 

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/tui/fk.py

@@ -20,7 +20,7 @@ from urllib.parse import urlsplit
 
 from pydantic import BaseModel, ConfigDict
 
-from nsc.model.command_model import CommandModel, Operation
+from nsc.model.command_model import CommandModel, Operation, Resource
 from nsc.tui.relations import singularize
 
 FkKind = Literal["picker", "raw_id"]
@@ -51,12 +51,27 @@ class FkTarget(BaseModel):
     hint: str | None = None
 
 
-def resolve_fk_target(field_name: str, current_value: Any, model: CommandModel) -> FkTarget:
+def resolve_fk_target(
+    field_name: str,
+    current_value: Any,
+    model: CommandModel,
+    *,
+    context_tag: str | None = None,
+    context_resource: str | None = None,
+) -> FkTarget:
     from_url = _resolve_from_url(field_name, current_value, model)
     if from_url is not None:
         return from_url
 
-    by_name = _resolve_by_field_name(field_name, model)
+    from_schema = _resolve_from_schema_fk(
+        field_name, model, context_tag=context_tag, context_resource=context_resource
+    )
+    if from_schema is not None:
+        return from_schema
+
+    by_name = _resolve_by_field_name(
+        field_name, model, context_tag=context_tag, context_resource=context_resource
+    )
     if by_name is not None:
         return by_name
 
@@ -67,6 +82,67 @@ def resolve_fk_target(field_name: str, current_value: Any, model: CommandModel)
     )
 
 
+def _resolve_from_schema_fk(
+    field_name: str,
+    model: CommandModel,
+    *,
+    context_tag: str | None,
+    context_resource: str | None,
+) -> FkTarget | None:
+    """Resolve via the schema-declared FK target of the owning resource's field.
+
+    The owning resource's create/update body types the field as a FK to a named
+    serializer (`fk_target`); `model.fk_resources` maps that serializer to the
+    resource that serves it. This resolves even when the field and resource names
+    diverge (a virtual-machine's `role` targets dcim `device-roles`).
+    """
+    if context_resource is None:
+        return None
+    resource = _find_resource(model, context_resource, prefer_tag=context_tag)
+    if resource is None:
+        return None
+    base = field_name[:-3] if field_name.endswith("_id") else field_name
+    component = _field_fk_target(resource, base)
+    if component is None:
+        return None
+    ref = model.fk_resources.get(component)
+    if ref is None:
+        return None
+    tag = model.tags.get(ref.tag)
+    target = tag.resources.get(ref.resource) if tag is not None else None
+    if target is None or target.list_op is None:
+        return None
+    return FkTarget(
+        kind="picker",
+        field_name=field_name,
+        tag=ref.tag,
+        resource_name=ref.resource,
+        list_op=target.list_op,
+    )
+
+
+def _field_fk_target(resource: Resource, base: str) -> str | None:
+    for op in (resource.create_op, resource.update_op, resource.replace_op):
+        if op is None or op.request_body is None:
+            continue
+        shape = op.request_body.fields.get(base)
+        if shape is not None and shape.fk_target is not None:
+            return shape.fk_target
+    return None
+
+
+def _find_resource(model: CommandModel, name: str, *, prefer_tag: str | None) -> Resource | None:
+    if prefer_tag is not None and prefer_tag in model.tags:
+        found = model.tags[prefer_tag].resources.get(name)
+        if found is not None:
+            return found
+    for tag_name in sorted(model.tags):
+        found = model.tags[tag_name].resources.get(name)
+        if found is not None:
+            return found
+    return None
+
+
 def _resolve_from_url(field_name: str, current_value: Any, model: CommandModel) -> FkTarget | None:
     if not isinstance(current_value, dict):
         return None
@@ -110,27 +186,61 @@ def _resolve_from_url(field_name: str, current_value: Any, model: CommandModel)
     )
 
 
-def _resolve_by_field_name(field_name: str, model: CommandModel) -> FkTarget | None:
+def _resolve_by_field_name(
+    field_name: str,
+    model: CommandModel,
+    *,
+    context_tag: str | None = None,
+    context_resource: str | None = None,
+) -> FkTarget | None:
     base = field_name[:-3] if field_name.endswith("_id") else field_name
     wanted = singularize(base)
-    for tag_name in sorted(model.tags):
-        tag = model.tags[tag_name]
-        for resource_name in sorted(tag.resources):
-            if singularize(resource_name) != wanted:
-                continue
-            resource = tag.resources[resource_name]
-            if resource.list_op is None:
-                continue
+
+    # NetBox reuses bare FK names across apps: a device's `role` targets dcim
+    # `device-roles`, an ipam prefix's `role` targets ipam `roles`. The bare name
+    # can't disambiguate (`device-roles` does not singularize to `role`), so when
+    # the owning resource is known we first try the qualified target name
+    # `<owner>-<field>` (e.g. `device-role`), preferring the owner's own tag,
+    # before falling back to the bare name's global scan.
+    candidates: list[str] = []
+    if context_resource is not None:
+        candidates.append(f"{singularize(context_resource)}-{wanted}")
+    candidates.append(wanted)
+
+    for candidate in candidates:
+        located = _match_resource_by_singular(model, candidate, prefer_tag=context_tag)
+        if located is not None:
+            tag_name, resource_name, list_op = located
             return FkTarget(
                 kind="picker",
                 field_name=field_name,
                 tag=tag_name,
                 resource_name=resource_name,
-                list_op=resource.list_op,
+                list_op=list_op,
             )
     return None
 
 
+def _match_resource_by_singular(
+    model: CommandModel, wanted: str, *, prefer_tag: str | None
+) -> tuple[str, str, Operation] | None:
+    for tag_name in _tag_search_order(model, prefer_tag):
+        tag = model.tags[tag_name]
+        for resource_name in sorted(tag.resources):
+            resource = tag.resources[resource_name]
+            if singularize(resource_name) != wanted or resource.list_op is None:
+                continue
+            return (tag_name, resource_name, resource.list_op)
+    return None
+
+
+def _tag_search_order(model: CommandModel, prefer_tag: str | None) -> list[str]:
+    rest = sorted(model.tags)
+    if prefer_tag is not None and prefer_tag in model.tags:
+        return [prefer_tag, *(t for t in rest if t != prefer_tag)]
+    return rest
+
+
 def _locate_resource(
     resource_name: str, model: CommandModel
 ) -> tuple[str, Operation | None] | None:

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/tui/forms.py

@@ -35,6 +35,9 @@ class WidgetSpec(BaseModel):
 
     kind: WidgetKind
     name: str
+    # Human-friendly row label; falls back to ``name`` when blank (regular fields
+    # keep their key as the label; custom fields carry their NetBox label here).
+    label: str = ""
     choices: tuple[str, ...] = ()
     nullable: bool = False
     sensitive: bool = False
@@ -83,15 +86,20 @@ def custom_field_widget(cf: CustomFieldDef) -> WidgetSpec:
     kind = _CF_KINDS.get(cf.type, "text")
     nullable = not cf.required
     if kind == "select":
-        return WidgetSpec(kind="select", name=name, choices=cf.choices, nullable=nullable)
+        return WidgetSpec(
+            kind="select", name=name, label=cf.label, choices=cf.choices, nullable=nullable
+        )
     if kind == "multi_select":
         return WidgetSpec(
             kind="multi_select",
             name=name,
+            label=cf.label,
             options=tuple((c, c) for c in cf.choices),
             nullable=nullable,
         )
-    return WidgetSpec(kind=kind, name=name, nullable=nullable, is_float=cf.type == "decimal")
+    return WidgetSpec(
+        kind=kind, name=name, label=cf.label, nullable=nullable, is_float=cf.type == "decimal"
+    )
 
 
 def expand_custom_fields(defs: dict[str, CustomFieldDef]) -> list[WidgetSpec]:
@@ -242,20 +250,25 @@ def diff_rows(
     patch: dict[str, object],
     sensitive_paths: tuple[str, ...],
     new_displays: dict[str, str] | None = None,
+    field_labels: dict[str, str] | None = None,
 ) -> list[DiffRow]:
     """Render ``patch`` as human-readable old -> new rows for the confirm modal.
 
     ``new_displays`` overrides a field's rendered *new* value — used for FK
     fields whose staged value is a bare id but whose chosen label is known
     (e.g. picked from the record chooser). The patch still carries the id.
+    ``field_labels`` overrides a field's *name* — used so a ``custom_fields.<name>``
+    key renders as its human label rather than the raw dotted key.
     """
     overrides = new_displays or {}
+    labels = field_labels or {}
     rows: list[DiffRow] = []
     for name, new_value in patch.items():
+        field = labels.get(name, name)
         if name in sensitive_paths:
-            rows.append(DiffRow(field=name, old_display="****", new_display="****"))
+            rows.append(DiffRow(field=field, old_display="****", new_display="****"))
             continue
         old_display = fk_display(original[name]) if name in original else ""
         new_display = overrides.get(name, str(new_value))
-        rows.append(DiffRow(field=name, old_display=old_display, new_display=new_display))
+        rows.append(DiffRow(field=field, old_display=old_display, new_display=new_display))
     return rows

{netbox_super_cli-1.6.0 → netbox_super_cli-1.6.2}/nsc/tui/screens/bulk_edit_form.py

@@ -100,9 +100,15 @@ class BulkEditForm(Screen[None]):
         self._fk_labels: dict[str, str] = {}
         body = update_op.request_body
         field_names = list(body.fields) if body is not None else []
+        # Custom fields are staged under flattened ``custom_fields.<name>`` keys,
+        # so seed their shared value from flattened records too — otherwise a
+        # widget defaults (e.g. a boolean to False) and opting it in unchanged
+        # would silently overwrite the records' shared value.
+        cf_names = [f"custom_fields.{cf.name}" for cf in (custom_field_defs or {}).values()]
+        flattened_records = [flatten_custom_fields(record) for record in selected_records]
         # Shared current value per field, to seed the widgets (does NOT opt the
         # field in — the include toggle still gates what gets set).
-        self._shared = shared_values(selected_records, field_names)
+        self._shared = shared_values(flattened_records, field_names + cf_names)
         self.progress_total = 0
         self.progress_done = 0
         self.title = f"Bulk edit {len(selected_records)} {resource_name}"
@@ -111,6 +117,10 @@ class BulkEditForm(Screen[None]):
     def bulk_set(self) -> dict[str, Any]:
         return {name: self._values[name] for name in self._included if name in self._values}
 
+    def _field_labels(self) -> dict[str, str]:
+        """Human labels for fields that carry one (custom fields), for the diff."""
+        return {name: spec.label for name, spec in self._specs.items() if spec.label}
+
     def compose(self) -> ComposeResult:
         yield Header()
         with VerticalScroll(id="bulk-form-body"):
@@ -142,7 +152,7 @@ class BulkEditForm(Screen[None]):
     def _compose_field(self, name: str, spec: WidgetSpec) -> ComposeResult:
         with Horizontal(classes="bulk-field"):
             yield Switch(value=False, id=f"include-{encode_field_id(name)}", classes="bulk-include")
-            yield Label(name, classes="bulk-label")
+            yield Label(spec.label or name, classes="bulk-label")
             yield from self._compose_widget(name, spec)
             if spec.nullable and spec.kind != "multi_select":
                 yield Button("∅", id=f"setnull-{encode_field_id(name)}", classes="bulk-setnull")
@@ -173,7 +183,13 @@ class BulkEditForm(Screen[None]):
         return str(shared_id)
 
     def _compose_fk(self, name: str) -> ComposeResult:
-        target = resolve_fk_target(name, self._fk_nested_value(name), self._model)
+        target = resolve_fk_target(
+            name,
+            self._fk_nested_value(name),
+            self._model,
+            context_tag=self._tag,
+            context_resource=self._resource_name,
+        )
         self._fk_kinds[name] = target.kind
         shared_id = self._shared.get(name)
         if target.kind == "raw_id":
@@ -191,8 +207,16 @@ class BulkEditForm(Screen[None]):
     def _compose_widget(self, name: str, spec: WidgetSpec) -> ComposeResult:
         wid = f"field-{encode_field_id(name)}"
         if spec.kind == "multi_select":
+            # Tags seed via spec.selected; a custom-field multiselect seeds its
+            # shared current list so opting it in unchanged isn't a destructive
+            # clear (tags are intentionally left blank — they have their own flow).
+            selected = set(spec.selected)
+            if not selected and name != "tags":
+                shared = self._shared.get(name)
+                if isinstance(shared, list):
+                    selected = {str(v) for v in shared}
             yield SelectionList[str](
-                *(Selection(label, val, val in spec.selected) for label, val in spec.options),
+                *(Selection(label, val, val in selected) for label, val in spec.options),
                 id=wid,
                 classes="bulk-multiselect",
             )
@@ -264,7 +288,10 @@ class BulkEditForm(Screen[None]):
             return self._multiselect_value(name, self.query_one(wid, SelectionList).selected)
         if spec is not None and spec.kind == "select":
             value = self.query_one(wid, Select).value
-            return None if value is Select.NULL else value
+            # A blank select (no/unresolved choices, or a current value not in the
+            # options) must not seed a null on opt-in — that would silently clear a
+            # field the user never edited. Only the explicit ∅ button nulls.
+            return _NO_SEED if value is Select.NULL else value
         if spec is not None and spec.kind == "switch":
             return self.query_one(wid, Switch).value
         return self._coerce_input(name, self.query_one(wid, Input).value)
@@ -279,6 +306,10 @@ class BulkEditForm(Screen[None]):
         name = self._strip(event.select.id, "field-")
         if name is None:
             return
+        # A blank select on a field the user hasn't opted in must not stage a null
+        # (which would clear the field on apply). Only the explicit ∅ button nulls.
+        if event.value is Select.NULL and name not in self._included:
+            return
         self._values[name] = None if event.value is Select.NULL else event.value
 
     def on_selection_list_selected_changed(self, event: SelectionList.SelectedChanged[str]) -> None:
@@ -306,7 +337,13 @@ class BulkEditForm(Screen[None]):
             self._open_picker(fk)
 
     def _open_picker(self, name: str) -> None:
-        target = resolve_fk_target(name, self._fk_nested_value(name), self._model)
+        target = resolve_fk_target(
+            name,
+            self._fk_nested_value(name),
+            self._model,
+            context_tag=self._tag,
+            context_resource=self._resource_name,
+        )
         if target.list_op is None:
             return
         from nsc.tui.screens.record_picker import RecordPicker  # noqa: PLC0415
@@ -329,7 +366,9 @@ class BulkEditForm(Screen[None]):
         sensitive = body.sensitive_paths if body is not None else ()
         # Flatten custom_fields so each chosen custom_fields.<name> diffs per record.
         flattened = [flatten_custom_fields(record) for record in self._selected]
-        changes = bulk_diff(flattened, self.bulk_set, sensitive, self._fk_labels)
+        changes = bulk_diff(
+            flattened, self.bulk_set, sensitive, self._fk_labels, self._field_labels()
+        )
 
         def _on_confirm(confirmed: bool | None) -> None:
             if confirmed: