ls supabase/migrations/ | sort | tail -5

-- Add the "default model" pointer from a cell specification to one of its
-- parameterized models. Nullable; cleared automatically if the PM is deleted.
-- Integrity that the PM belongs to the same spec is enforced in the service
-- layer (see cell_specification_service.update_cell_spec_nested), not by a
-- composite FK.
ALTER TABLE cell_specifications
  ADD COLUMN IF NOT EXISTS default_parameterized_model_id uuid
  REFERENCES parameterized_models(id) ON DELETE SET NULL;

CREATE INDEX IF NOT EXISTS idx_cell_specifications_default_pm
  ON cell_specifications(default_parameterized_model_id);

supabase migration up

psql "$SUPABASE_DB_URL" -c "\d cell_specifications" | grep default_parameterized_model_id

git add supabase/migrations/<ts>_add_default_parameterized_model_to_cell_specs.sql
git commit -m "feat(db): add default_parameterized_model_id to cell_specifications"

    default_parameterized_model_id: str | None = Field(
        None,
        description=(
            "ID of the parameterized model marked as this specification's "
            "default model, or None if unset."
        ),
    )

    default_parameterized_model_id: str | None = Field(
        None,
        description=(
            "Set the default parameterized model for this specification. Must "
            "reference one of this specification's own parameterized models. "
            "Pass null to clear the default."
        ),
    )

just test-backend backend/tests/test_pydantic_models -q -k cell 2>/dev/null || uv run python -c "from src.pydantic_models.cells import CellSpecification, UpdateCellSpecificationNested; print('ok')"

git add backend/src/pydantic_models/cells.py
git commit -m "feat(cells): add default_parameterized_model_id to cell spec models"

import pytest
from unittest.mock import AsyncMock

from src.services.default_parameterized_model import set_default_pm_if_unset


@pytest.mark.asyncio
async def test_sets_default_when_unset():
    spec = AsyncMock()
    spec.default_parameterized_model_id = None
    repo = AsyncMock()
    repo.get_cell_specification.return_value = spec

    await set_default_pm_if_unset(repo, "spec-1", "pm-1")

    repo.update_cell_specification.assert_awaited_once_with(
        "spec-1", {"default_parameterized_model_id": "pm-1"}
    )


@pytest.mark.asyncio
async def test_noop_when_already_set():
    spec = AsyncMock()
    spec.default_parameterized_model_id = "pm-existing"
    repo = AsyncMock()
    repo.get_cell_specification.return_value = spec

    await set_default_pm_if_unset(repo, "spec-1", "pm-1")

    repo.update_cell_specification.assert_not_awaited()


@pytest.mark.asyncio
async def test_noop_when_spec_missing():
    repo = AsyncMock()
    repo.get_cell_specification.return_value = None

    await set_default_pm_if_unset(repo, "spec-1", "pm-1")

    repo.update_cell_specification.assert_not_awaited()

"""Shared helper for auto-populating a cell spec's default parameterized model.

Called from every parameterized-model-creation site that supplies a
``cell_spec_id`` so the first model created for a specification becomes its
default. Never overrides an existing default.
"""

from src.repositories.cell_specifications import CellSpecificationRepository


async def set_default_pm_if_unset(
    cell_spec_repo: CellSpecificationRepository,
    cell_spec_id: str,
    parameterized_model_id: str,
) -> None:
    """Set ``cell_spec_id``'s default parameterized model if it has none yet.

    Parameters
    ----------
    cell_spec_repo : CellSpecificationRepository
        Repository used to read and update the cell specification.
    cell_spec_id : str
        Cell specification to (maybe) update.
    parameterized_model_id : str
        Parameterized model to install as the default when none is set.
    """
    spec = await cell_spec_repo.get_cell_specification(cell_spec_id)
    if spec is None or spec.default_parameterized_model_id is not None:
        return
    await cell_spec_repo.update_cell_specification(
        cell_spec_id,
        {"default_parameterized_model_id": parameterized_model_id},
    )

git add backend/src/services/default_parameterized_model.py backend/tests/test_services/test_default_parameterized_model_helper.py
git commit -m "feat(cells): add shared auto-default parameterized-model helper"

grep -rln "update_cell_spec_nested" backend/tests/

# 1. Valid PM belonging to this spec -> persisted
#    - parameterized_model_repo.get_parameterized_model_by_id returns a PM
#      whose cell_spec_id == the spec id
#    - assert update payload includes default_parameterized_model_id
# 2. PM belonging to a different spec -> BadRequestError
# 3. Non-existent PM (repo returns None) -> BadRequestError
# 4. Explicit null clears (field in model_fields_set, value None)
#    -> payload includes default_parameterized_model_id: None, no PM lookup
# 5. Field omitted -> no default_parameterized_model_id key in payload,
#    no PM lookup

from src.repositories.parameterized_models import ParameterizedModelsRepository
from src.deps import get_parameterized_models_repository  # confirm exact name

grep -rn "ParameterizedModelsRepository" backend/src/deps.py backend/src/routes/parameterized_models.py

        parameterized_model_repo: Annotated[
            ParameterizedModelsRepository,
            Depends(get_parameterized_models_repository),
        ],
    ):
        ...
        self.parameterized_model_repo = parameterized_model_repo

        if "default_parameterized_model_id" in data.model_fields_set:
            new_default = data.default_parameterized_model_id
            if new_default is not None:
                pm = await self.parameterized_model_repo.get_parameterized_model_by_id(
                    new_default
                )
                if pm is None or pm.cell_spec_id != cell_spec_id:
                    raise BadRequestError(
                        f"Parameterized model '{new_default}' does not belong to "
                        f"cell specification '{cell_spec_id}'. The default model "
                        f"must be one of this specification's own parameterized "
                        f"models."
                    )
            update_payload["default_parameterized_model_id"] = new_default

git add backend/src/services/cell_specification_service.py backend/src/deps.py backend/tests/test_services/test_cell_specification_default_model.py
git commit -m "feat(cells): validate and persist default_parameterized_model_id on update"

from src.repositories.cell_specifications import CellSpecificationRepository
from src.services.default_parameterized_model import set_default_pm_if_unset

    if cell_spec_id:
        await set_default_pm_if_unset(
            CellSpecificationRepository(supabase_client),
            cell_spec_id,
            str(created_pm.id),
        )

            cs_id = model_config.get("cell_spec_id")
            if cs_id:
                await set_default_pm_if_unset(
                    CellSpecificationRepository(
                        parameterized_models_repository.supabase
                    ),
                    cs_id,
                    str(parameterized_model_record.id),
                )

just test-backend backend/tests/ -k "ecm or cycler_protocol" -v

cd backend && uv run python -c "import src.services.ecm, src.services.cycler_protocol_service; print('ok')"

git add backend/src/services/ecm.py backend/src/services/cycler_protocol_service.py
git commit -m "feat(cells): auto-set default parameterized model at both creation sites"

ls frontend/src/redux/api/*.test.ts; grep -rln "mockAxios" frontend/src/redux/api | head

  default_parameterized_model_id?: string | null;

it('updateCell PATCHes /cell_specifications/:id with the body', async () => {
  const store = makeTestStore();
  mockAxios.onPatch('/cell_specifications/spec-1').reply(200, {
    id: 'spec-1',
    name: 'Spec',
    default_parameterized_model_id: 'pm-1',
  });

  await store
    .dispatch(
      cellsApi.endpoints.updateCell.initiate({
        cellSpecId: 'spec-1',
        body: { default_parameterized_model_id: 'pm-1' },
      })
    )
    .unwrap();

  const patchCall = mockAxios.history.patch[0];
  expect(patchCall.url).toBe('/cell_specifications/spec-1');
  expect(JSON.parse(patchCall.data)).toEqual({
    default_parameterized_model_id: 'pm-1',
  });
});

type UpdateCellBody = Partial<Pick<Cell, 'default_parameterized_model_id'>>;

    updateCell: builder.mutation<Cell, { cellSpecId: string; body: UpdateCellBody }>({
      query: ({ cellSpecId, body }) => ({
        url: `/cell_specifications/${cellSpecId}`,
        method: 'patch',
        data: body,
      }),
      transformResponse: (cell: any) => mapCell(cell),
      invalidatesTags: (result, error, { cellSpecId }) =>
        invalidateOnSuccess([{ type: 'Cell', id: cellSpecId }])(result, error, undefined),
    }),

git add frontend/src/redux/types/cell.ts frontend/src/redux/api/cells-api.ts frontend/src/redux/api/__tests__/cells-api.test.ts
git commit -m "feat(cells): add updateCell mutation + default_parameterized_model_id mapping"

import { Chip } from '@mui/material';
import { useGetCellQuery, useUpdateCellMutation } from 'src/redux/api/cells-api';
import { CustomGridActionsCellItem } from 'src/components/custom-data-grid';
import { Iconify } from 'src/components/iconify';
import { toast } from 'src/components/snackbar';
import { extractApiError } from 'src/utils/api-error';

  const { data: cellSpec } = useGetCellQuery(specId);
  const defaultPmId = cellSpec?.default_parameterized_model_id ?? null;
  const [updateCell] = useUpdateCellMutation();

  const handleSetDefault = useCallback(
    async (pmId: string, pmName: string) => {
      try {
        await updateCell({
          cellSpecId: specId,
          body: { default_parameterized_model_id: pmId },
        }).unwrap();
        toast.success(`Set "${pmName}" as the default model`);
      } catch (error) {
        toast.error(extractApiError(error, 'Failed to set default model').message);
      }
    },
    [specId, updateCell]
  );

        renderCell: (params: GridRenderCellParams) => (
          <Stack direction="row" spacing={1} alignItems="center">
            <Typography
              component={RouterLink}
              href={paths.dashboard.parameterizedModels.detail(projectId, params.row.id)}
              sx={{ color: COLORS.link }}
              variant="body2"
              lineHeight="inherit"
            >
              {params.value}
            </Typography>
            {params.row.id === defaultPmId && (
              <Chip label="Default" size="small" color="primary" />
            )}
          </Stack>
        ),

      {
        field: 'actions',
        type: 'actions',
        align: 'center',
        headerAlign: 'center',
        width: 40,
        sortable: false,
        filterable: false,
        disableColumnMenu: true,
        getActions: (params) => [
          <CustomGridActionsCellItem
            key="set-default"
            showInMenu
            icon={<Iconify icon="mdi:star-outline" />}
            label="Set as default"
            disabled={params.row.id === defaultPmId}
            onClick={() => handleSetDefault(params.row.id, params.row.name)}
          />,
        ],
      },

git add frontend/src/sections/data-management/components/spec-parameterized-models-tab.tsx
git commit -m "feat(cells): default chip + set-as-default action on spec PM tab"

import { Chip } from '@mui/material';
import { useGetCellQuery, useUpdateCellMutation } from 'src/redux/api/cells-api';

  const { data: cellSpec } = useGetCellQuery(
    parameterizedModel?.cell_spec_id ?? skipToken
  );
  const [updateCell] = useUpdateCellMutation();
  const isDefault =
    !!parameterizedModel &&
    cellSpec?.default_parameterized_model_id === parameterizedModel.id;

  const handleSetDefault = async () => {
    if (!parameterizedModel?.cell_spec_id) return;
    try {
      await updateCell({
        cellSpecId: parameterizedModel.cell_spec_id,
        body: { default_parameterized_model_id: parameterizedModel.id },
      }).unwrap();
      toast.success(`Set "${parameterizedModel.name}" as the default model`);
    } catch (error) {
      toast.error(extractApiError(error, 'Failed to set default model').message);
    }
  };

            {isDefault && <Chip label="Default model" size="small" color="primary" />}

            {!isDefault && parameterizedModel.cell_spec_id && (
              <Button
                variant="outlined"
                startIcon={<Iconify icon="mdi:star-outline" />}
                onClick={handleSetDefault}
              >
                Set as default
              </Button>
            )}

git add frontend/src/sections/parameterized-model/containers/parameterized-model-details-container.tsx
git commit -m "feat(cells): default badge + set-as-default button on PM detail page"

git add frontend/e2e/cell-spec-default-model.spec.ts
git commit -m "test(e2e): cell spec default model chip + set-as-default"

just test-backend backend/tests/test_services/ -k "cell or default_parameterized or ecm or cycler" -v
just test-frontend-unit